\documentclass{report}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage{geometry}
\geometry{top=15mm, bottom=15mm, left=1cm, right=1cm}
\usepackage[french]{babel}
\usepackage{pslatex}
\usepackage[colorlinks=true,urlcolor=black]{hyperref}
\usepackage{graphicx}
\usepackage{fancyhdr}
\pagestyle{fancy}
\renewcommand{\footrulewidth}{0.4pt}
\fancyfoot[L]{Uubu.fr}
\fancyfoot[R]{mar. mai 4 01:59:21 CEST 2010}
\lfoot{\Large \textit{Uubu.fr}}
\hypersetup{pdfinfo={
Title={MySQL - Le langage},
Author={Sylvain Girod},
Creator={Bash script from uubu.fr's format version 1},
Producer={Bash script and PDFLaTeX},
Subject={Description du langage MySQL},
CreationDate={D:20100504015921},
ModDate={D:20100504015921},
Keywords={mysql;db;databases}
}}
\begin{document}
 
\begin{center}
{\Huge MySQL - Le langage }
\end{center}
\vspace{1cm}
 
\begin{flushleft}
 
{\large Description du langage MySQL}
 
\vspace{10mm}
 
\vspace{1cm}{\huge Chaînes }
 
\
 
\hspace{1mm}  Si le serveur est en mode \textbf{ANSI\_QUOTES}, les chaînes ne peuvent être mises qu'entre guillemets simples
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} \textbackslash{}0]{un 0 ASCII(NUL)}
\item[\hspace{1mm} \textbackslash{}']{guillemet simple}
\item[\hspace{1mm} \textbackslash{}"]{guillemet double}
\item[\hspace{1mm} \textbackslash{}b]{effacement}
\item[\hspace{1mm} \textbackslash{}n]{nouvelle ligne}
\item[\hspace{1mm} \textbackslash{}r]{retour chariot}
\item[\hspace{1mm} \textbackslash{}t]{tabulation}
\item[\hspace{1mm} \textbackslash{}z]{ASCII(26)(Control-Z) Peut être encodé pour éviter des problèmes avec windows, puisqu'il équivaut à une fin de fichier}
\item[\hspace{1mm} \textbackslash{}\textbackslash{}]{un anti-slash}
\item[\hspace{1mm} \textbackslash{}\%]{un signe pourcentage littéral}
\item[\hspace{1mm} \textbackslash{}\_]{Un signe souligné littéral}
\end{description}
 
\hspace{1mm}  Si vous voulez insérer des données binaires dans un champ chaîne (comme un \textbf{BLOB}), les caractères suivants doivent être échappés:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} NUL]{ASCII 0}
\item[\hspace{1mm} \textbackslash{}]{ASCII 92}
\item[\hspace{1mm} ']{ASCII 39}
\item[\hspace{1mm} "]{ASCII 34}
\end{description}
 
\vspace{1cm}{\huge Les nombres }
 
\
 
\hspace{1mm} Valeurs hexadécimales: \\
\hspace{1mm} \textbf{mysql> SELECT x'4D7953514C';} \\
\hspace{1mm} \textbf{-> 'MySQL'} \\
\hspace{1mm} \textbf{mysql> SELECT 0xa+0;} \\
\hspace{1mm} \textbf{-> 10} \\
\hspace{1mm} \textbf{mysql> SELECT 0x5061756c;} \\
\hspace{1mm} \textbf{-> 'Paul'} \\
\hspace{1mm} \textbf{mysql> SELECT 0x41, CAST(0x41 AS UNSIGNED);} \\
\hspace{1mm} \textbf{-> 'A', 65} \\
\hspace{1mm} \textbf{mysql> SELECT HEX('cat');} \\
\hspace{1mm} \textbf{-> '636174'} \\
\hspace{1mm} \textbf{mysql> SELECT 0x636174;} \\
\hspace{1mm} \textbf{-> 'cat'} \\
\hspace{1mm} Valeurs booléennes: \\
\hspace{1mm} \textbf{TRUE vaut 1 et FALSE vaut 0} \\
\hspace{1mm} champs de bits: \\
\hspace{1mm} \textbf{mysql> CREATE TABLE t (b BIT(8));} \\
\hspace{1mm} \textbf{mysql> INSERT INTO t SET b = b'11111111';} \\
\hspace{1mm} \textbf{mysql> INSERT INTO t SET b = b'1010';} \\
 
\hspace{1mm}  Valeurs NULL : signifie "pas de données" et est différent des valeurs comme 0 ou des chaînes vides
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Noms de bases, tables, index, colonnes et alias }
 
\
 
\hspace{1mm}  limité a 64 octets(255 pour les alias). les identifiants sont stockés en utf8 et peuvent être entre guillemets
\vspace{5mm} \\
 
 
\hspace{1mm} caractères de protection pour les identifiants contenant des caractères spéciaux ou sont un mot réservé : \\
\hspace{1mm} \textbf{`} \\
\hspace{1mm} \textbf{mysql> SELECT * FROM `select` WHERE `select`.id > 100;} \\
\hspace{1mm} identifiants. Pour faire référence à une colonne: \\
\hspace{1mm} \textbf{col\_name} \\
\hspace{1mm} \textbf{tbl\_name.col\_name} \\
\hspace{1mm} \textbf{db\_name.tbl\_name.col\_name} \\
\hspace{1mm} commentaires: \\
\hspace{1mm} \textbf{\# ceci est un commentaire} \\
\hspace{1mm} \textbf{— ceci est un commentaire} \\
\hspace{1mm} \textbf{/* ceci} \\
\hspace{1mm} \textbf{est un} \\
\hspace{1mm} \textbf{commentaire */} \\
 
\vspace{1cm}{\huge Mots clé réservés }
 
\
 
{\ttfamily
ADD\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ALL\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ALTER\\ ANALYZE\_\_\_\_\_\_\_\_\_\_\_\_\_AND\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_AS\\ ASC\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ASENSITIVE\_\_\_\_\_\_\_\_BEFORE\\ BETWEEN\_\_\_\_\_\_\_\_\_\_\_\_\_BIGINT\_\_\_\_\_\_\_\_\_\_\_\_BINARY\\ BLOB\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_BOTH\_\_\_\_\_\_\_\_\_\_\_\_\_\_BY\\ CALL\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_CASCADE\_\_\_\_\_\_\_\_\_\_\_CASE\\ CHANGE\_\_\_\_\_\_\_\_\_\_\_\_\_\_CHAR\_\_\_\_\_\_\_\_\_\_\_\_\_\_CHARACTER\\ CHECK\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_COLLATE\_\_\_\_\_\_\_\_\_\_\_COLUMN\\ CONDITION\_\_\_\_\_\_\_\_\_\_\_CONSTRAINT\_\_\_\_\_\_\_\_CONTINUE\\ CONVERT\_\_\_\_\_\_\_\_\_\_\_\_\_CREATE\_\_\_\_\_\_\_\_\_\_\_\_CROSS\\ CURRENT\_DATE\_\_\_\_\_\_\_\_CURRENT\_TIME\_\_\_\_\_\_CURRENT\_TIMESTAMP\\ CURRENT\_USER\_\_\_\_\_\_\_\_CURSOR\_\_\_\_\_\_\_\_\_\_\_\_DATABASE\\ DATABASES\_\_\_\_\_\_\_\_\_\_\_DAY\_HOUR\_\_\_\_\_\_\_\_\_\_DAY\_MICROSECOND\\ DAY\_MINUTE\_\_\_\_\_\_\_\_\_\_DAY\_SECOND\_\_\_\_\_\_\_\_DEC\\ DECIMAL\_\_\_\_\_\_\_\_\_\_\_\_\_DECLARE\_\_\_\_\_\_\_\_\_\_\_DEFAULT\\ DELAYED\_\_\_\_\_\_\_\_\_\_\_\_\_DELETE\_\_\_\_\_\_\_\_\_\_\_\_DESC\\ DESCRIBE\_\_\_\_\_\_\_\_\_\_\_\_DETERMINISTIC\_\_\_\_\_DISTINCT\\ DISTINCTROW\_\_\_\_\_\_\_\_\_DIV\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_DOUBLE\\ DROP\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_DUAL\_\_\_\_\_\_\_\_\_\_\_\_\_\_EACH\\ ELSE\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ELSEIF\_\_\_\_\_\_\_\_\_\_\_\_ENCLOSED\\ ESCAPED\_\_\_\_\_\_\_\_\_\_\_\_\_EXISTS\_\_\_\_\_\_\_\_\_\_\_\_EXIT\\ EXPLAIN\_\_\_\_\_\_\_\_\_\_\_\_\_FALSE\_\_\_\_\_\_\_\_\_\_\_\_\_FETCH\\ FLOAT\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_FLOAT4\_\_\_\_\_\_\_\_\_\_\_\_FLOAT8\\ FOR\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_FORCE\_\_\_\_\_\_\_\_\_\_\_\_\_FOREIGN\\ FROM\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_FULLTEXT\_\_\_\_\_\_\_\_\_\_GRANT\\ GROUP\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_HAVING\_\_\_\_\_\_\_\_\_\_\_\_HIGH\_PRIORITY\\ HOUR\_MICROSECOND\_\_\_\_HOUR\_MINUTE\_\_\_\_\_\_\_HOUR\_SECOND\\ IF\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_IGNORE\_\_\_\_\_\_\_\_\_\_\_\_IN\\ INDEX\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_INFILE\_\_\_\_\_\_\_\_\_\_\_\_INNER\\ INOUT\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_INSENSITIVE\_\_\_\_\_\_\_INSERT\\ INT\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_INT1\_\_\_\_\_\_\_\_\_\_\_\_\_\_INT2\\ INT3\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_INT4\_\_\_\_\_\_\_\_\_\_\_\_\_\_INT8\\ INTEGER\_\_\_\_\_\_\_\_\_\_\_\_\_INTERVAL\_\_\_\_\_\_\_\_\_\_INTO\\ IS\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ITERATE\_\_\_\_\_\_\_\_\_\_\_JOIN\\ KEY\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_KEYS\_\_\_\_\_\_\_\_\_\_\_\_\_\_KILL\\ LEADING\_\_\_\_\_\_\_\_\_\_\_\_\_LEAVE\_\_\_\_\_\_\_\_\_\_\_\_\_LEFT\\ LIKE\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_LIMIT\_\_\_\_\_\_\_\_\_\_\_\_\_LINES\\ LOAD\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_LOCALTIME\_\_\_\_\_\_\_\_\_LOCALTIMESTAMP\\ LOCK\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_LONG\_\_\_\_\_\_\_\_\_\_\_\_\_\_LONGBLOB\\ LONGTEXT\_\_\_\_\_\_\_\_\_\_\_\_LOOP\_\_\_\_\_\_\_\_\_\_\_\_\_\_LOW\_PRIORITY\\ MATCH\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_MEDIUMBLOB\_\_\_\_\_\_\_\_MEDIUMINT\\ MEDIUMTEXT\_\_\_\_\_\_\_\_\_\_MIDDLEINT\_\_\_\_\_\_\_\_\_MINUTE\_MICROSECOND\\ MINUTE\_SECOND\_\_\_\_\_\_\_MOD\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_MODIFIES\\ NATURAL\_\_\_\_\_\_\_\_\_\_\_\_\_NOT\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_NO\_WRITE\_TO\_BINLOG\\ NULL\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_NUMERIC\_\_\_\_\_\_\_\_\_\_\_ON\\ OPTIMIZE\_\_\_\_\_\_\_\_\_\_\_\_OPTION\_\_\_\_\_\_\_\_\_\_\_\_OPTIONALLY\\ OR\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ORDER\_\_\_\_\_\_\_\_\_\_\_\_\_OUT\\ OUTER\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_OUTFILE\_\_\_\_\_\_\_\_\_\_\_PRECISION\\ PRIMARY\_\_\_\_\_\_\_\_\_\_\_\_\_PROCEDURE\_\_\_\_\_\_\_\_\_PURGE\\ READ\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_READS\_\_\_\_\_\_\_\_\_\_\_\_\_REAL\\ REFERENCES\_\_\_\_\_\_\_\_\_\_REGEXP\_\_\_\_\_\_\_\_\_\_\_\_RELEASE\\ RENAME\_\_\_\_\_\_\_\_\_\_\_\_\_\_REPEAT\_\_\_\_\_\_\_\_\_\_\_\_REPLACE\\ REQUIRE\_\_\_\_\_\_\_\_\_\_\_\_\_RESTRICT\_\_\_\_\_\_\_\_\_\_RETURN\\ REVOKE\_\_\_\_\_\_\_\_\_\_\_\_\_\_RIGHT\_\_\_\_\_\_\_\_\_\_\_\_\_RLIKE\\ SCHEMA\_\_\_\_\_\_\_\_\_\_\_\_\_\_SCHEMAS\_\_\_\_\_\_\_\_\_\_\_SECOND\_MICROSECOND\\ SELECT\_\_\_\_\_\_\_\_\_\_\_\_\_\_SENSITIVE\_\_\_\_\_\_\_\_\_SEPARATOR\\ SET\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_SHOW\_\_\_\_\_\_\_\_\_\_\_\_\_\_SMALLINT\\ SONAME\_\_\_\_\_\_\_\_\_\_\_\_\_\_SPATIAL\_\_\_\_\_\_\_\_\_\_\_SPECIFIC\\ SQL\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_SQLEXCEPTION\_\_\_\_\_\_SQLSTATE\\ SQLWARNING\_\_\_\_\_\_\_\_\_\_SQL\_BIG\_RESULT\_\_\_\_SQL\_CALC\_FOUND\_ROWS\\ SQL\_SMALL\_RESULT\_\_\_\_SSL\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_STARTING\\ STRAIGHT\_JOIN\_\_\_\_\_\_\_TABLE\_\_\_\_\_\_\_\_\_\_\_\_\_TERMINATED\\ THEN\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_TINYBLOB\_\_\_\_\_\_\_\_\_\_TINYINT\\ TINYTEXT\_\_\_\_\_\_\_\_\_\_\_\_TO\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_TRAILING\\ TRIGGER\_\_\_\_\_\_\_\_\_\_\_\_\_TRUE\_\_\_\_\_\_\_\_\_\_\_\_\_\_UNDO\\ UNION\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_UNIQUE\_\_\_\_\_\_\_\_\_\_\_\_UNLOCK\\ UNSIGNED\_\_\_\_\_\_\_\_\_\_\_\_UPDATE\_\_\_\_\_\_\_\_\_\_\_\_USAGE\\ USE\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_USING\_\_\_\_\_\_\_\_\_\_\_\_\_UTC\_DATE\\ UTC\_TIME\_\_\_\_\_\_\_\_\_\_\_\_UTC\_TIMESTAMP\_\_\_\_\_VALUES\\ VARBINARY\_\_\_\_\_\_\_\_\_\_\_VARCHAR\_\_\_\_\_\_\_\_\_\_\_VARCHARACTER\\ VARYING\_\_\_\_\_\_\_\_\_\_\_\_\_WHEN\_\_\_\_\_\_\_\_\_\_\_\_\_\_WHERE\\ WHILE\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_WITH\_\_\_\_\_\_\_\_\_\_\_\_\_\_WRITE\\ XOR\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_YEAR\_MONTH\_\_\_\_\_\_\_\_ZEROFILL\\
}
\vspace{8mm}
 
\hspace{1mm}  Voici de nouveaux mots réservés en MySQL 5.0:
\vspace{5mm} \\
 
 
{\ttfamily
ASENSITIVE\_\_\_\_\_\_\_\_\_\_CALL\_\_\_\_\_\_\_\_\_\_\_\_\_\_CONDITION\\ CONTINUE\_\_\_\_\_\_\_\_\_\_\_\_CURSOR\_\_\_\_\_\_\_\_\_\_\_\_DECLARE\\ DETERMINISTIC\_\_\_\_\_\_\_EACH\_\_\_\_\_\_\_\_\_\_\_\_\_\_ELSEIF\\ EXIT\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_FETCH\_\_\_\_\_\_\_\_\_\_\_\_\_INOUT\\ INSENSITIVE\_\_\_\_\_\_\_\_\_ITERATE\_\_\_\_\_\_\_\_\_\_\_LEAVE\\ LOOP\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_MODIFIES\_\_\_\_\_\_\_\_\_\_OUT\\ READS\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_RELEASE\_\_\_\_\_\_\_\_\_\_\_REPEAT\\ RETURN\_\_\_\_\_\_\_\_\_\_\_\_\_\_SCHEMA\_\_\_\_\_\_\_\_\_\_\_\_SCHEMAS\\ SENSITIVE\_\_\_\_\_\_\_\_\_\_\_SPECIFIC\_\_\_\_\_\_\_\_\_\_SQL\\ SQLEXCEPTION\_\_\_\_\_\_\_\_SQLSTATE\_\_\_\_\_\_\_\_\_\_SQLWARNING\\ TRIGGER\_\_\_\_\_\_\_\_\_\_\_\_\_UNDO\_\_\_\_\_\_\_\_\_\_\_\_\_\_WHILE\\
}
\vspace{8mm}
 
\vspace{1cm}{\huge Types de colonnes - numériques }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -]{si vous spécifiez l'option \textbf{ZEROFILL} pour une valeur numérique, mysql ajoute automatiquement l'attribut \textbf{UNSIGNED} à la colonne.}
\item[\hspace{1mm} TINYINT\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un très petit entier. L'intervalle de validité pour les entiers signés est de -128 à 127. L'intervalle de validité pour les entiers non-signés est 0 à 255.}
\item[\hspace{1mm} BIT, BOOL, BOOLEAN]{Ce sont des synonymes de TINYINT(1). Un type booléen complet, qui sera introduit pour être en accord avec la norme SQL-99.}
\item[\hspace{1mm} SMALLINT\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un petit entier. L'intervalle de validité pour les entiers signés est de -32768 à 32767. L'intervalle de validité pour les entiers non-signés est 0 à 65535.}
\item[\hspace{1mm} MEDIUMINT\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un entier. L'intervalle de validité pour les entiers signés est de -8388608 à 8388607. L'intervalle de validité pour les entiers non-signés est 0 à 16777215.}
\item[\hspace{1mm} INT\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un grand entier. L'intervalle de validité pour les entiers signés est de -2147483648 à 2147483647. L'intervalle de validité pour les entiers non-signés est 0 à 4294967295.}
\item[\hspace{1mm} INTEGER\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Synonyme INT.}
\item[\hspace{1mm} BIGINT\texttt{[}(M)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un très grand entier. L'intervalle de validité pour les entiers signés est de -9223372036854775808 à 9223372036854775807. L'intervalle de validité pour les entiers non-signés est 0 à 18446744073709551615.}
\end{description}
 
\hspace{1mm}  \textbf{Quelques conseils à suivre avec les colonnes de type BIGINT}:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} -]{Tous les calculs arithmétiques sont fait en utilisant des BIGINT signés ou des valeurs DOUBLE. Il est donc recommandé de ne pas utiliser de grands entiers non-signés dont la taille dépasse 9223372036854775807 (63 bits), hormis avec les fonctions sur les bits! Si vous faîtes cela, les derniers chiffres du résultats risquent d'être faux, à cause des erreurs d'arrondis lors de la conversion de BIGINT en DOUBLE.}
\item[\hspace{1mm} ]{MySQL peut gérer des BIGINT dans les cas suivants:}
\item[\hspace{1mm} -]{Utiliser des entiers pour stocker des grandes valeurs entières non signées, dans une colonne de type BIGINT.}
\item[\hspace{1mm} -]{Avec MIN(big\_int\_column) et MAX(big\_int\_column).}
\item[\hspace{1mm} -]{Avec les opérateurs (+, -, *, etc.) où tous les opérandes sont des entiers.}
\item[\hspace{1mm} -]{Vous pouvez toujours stocker une valeur entière exacte BIGINT dans une colonne de type chaîne. Dans ce cas, MySQL fera des conversions chaîne / nombre, qui n'utilisera pas de représentation intermédiaire en nombre réels.}
\end{description}
 
\hspace{1mm}  ‘-’, ‘+’ et ‘*’ utiliseront l'arithmétique entière des BIGINT lorsque les deux arguments sont des entiers. Cela signifie que si vous multipliez deux entiers (ou des résultats de fonctions qui retournent des entiers), vous pourriez rencontrer des résultats inattendus lorsque le résultat est plus grand que 9223372036854775807.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} FLOAT(precision) \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un nombre à virgule flottante. précision peut valoir <=24 pour une précision simple, et entre 25 et 53 pour une précision double. Ces types sont identiques aux types FLOAT et DOUBLE, décrit ci-dessous. FLOAT(X) a le même intervalle de validité que FLOAT et DOUBLE, mais la taille d'affichage et le nombre de décimales est indéfini.}
\end{description}
 
\hspace{1mm}  En MySQL version 3.23, c'est un véritable nombre à virgule flottante. Dans les versions antérieures, FLOAT(precision) avait toujours 2 décimales. Notez qu'utiliser FLOAT peut vous donner des résultats inattendus, car tous les calculs de MySQL sont fait en double précision. Cette syntaxe est fournie pour assurer la compatibilité avec ODBC. Utiliser des FLOAT peut vous donner des résultats inattendus, car les calculs sont fait en précision double.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} FLOAT\texttt{[}(M,D)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un petit nombre à virgule flottante, en précision simple. Les valeurs possibles vont de -3.402823466E+38 à -1.175494351E-38, 0, et 1.175494351E-38 à 3.402823466E+38. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. L'attribut M indique la taille de l'affichage, et D est le nombre de décimales. FLOAT sans argument et FLOAT(X) (où X est dans l'intervalle 0 à 24) représente les nombres à virgule flottante en précision simple.}
\item[\hspace{1mm} DOUBLE\texttt{[}(M,D)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un nombre à virgule flottante, en précision double. Les valeurs possibles vont de -1.7976931348623157E+308 à -2.2250738585072014E-308, 0, et 2.2250738585072014E-308 à 1.7976931348623157E+308. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. L'attribut M indique la taille de l'affichage, et D est le nombre de décimales. DOUBLE sans argument et FLOAT(X) (où X est dans l'intervale 25 to 53) représente les nombres à virgule flottante en précision double.}
\item[\hspace{1mm} DOUBLE PRECISION\texttt{[}(M,D)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}, REAL\texttt{[}(M,D)\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Ce sont des synonymes pour DOUBLE. Exception : si le serveur SQL utilise l'option REAL\_AS\_FLOAT, REAL est alors un synonyme de FLOAT plutôt que DOUBLE.}
\item[\hspace{1mm} DECIMAL\texttt{[}(M\texttt{[},D\texttt{]})\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Un nombre à virgule flottante littéral. Il se comporte comme une colonne de type CHAR : "littéral" ("unpacked") signifie que le nombre est stocké sous forme de chaîne : chaque caractère représente un chiffre. La virgule décimale et le signe moins ‘-’ des nombres négatifs ne sont pas comptés dans M (mais de l'espace leur est réservé). Si D vaut 0, les valeurs n'auront pas de virgule décimale ou de partie décimale. L'intervale de validité du type DECIMAL est le même que DOUBLE, mais le vrai intervalle de validité de DECIMAL peut être restreint par le choix de la valeur de M et D. Si UNSIGNED est spécifié, les valeurs négatives sont interdites. Si D est omis, la valeur par défaut est 0. Si M est omis, la valeur par défaut est 10.}
\item[\hspace{1mm} DEC\texttt{[}(M\texttt{[},D\texttt{]})\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}, NUMERIC\texttt{[}(M\texttt{[},D\texttt{]})\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}, FIXED\texttt{[}(M\texttt{[},D\texttt{]})\texttt{]} \texttt{[}UNSIGNED\texttt{]} \texttt{[}ZEROFILL\texttt{]}]{Ce sont des synonymes pour DECIMAL}
\end{description}
 
\vspace{1cm}{\huge Types de colonnes - dates et heures }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} DATE]{Une date. L'intervalle supporté va de '1000-01-01' à '9999-12-31'. MySQL affiche les valeurs de type DATE au format 'YYYY-MM-DD', mais vous permet d'assigner des valeurs DATE en utilisant plusieurs formats de chaînes et nombres.}
\item[\hspace{1mm} DATETIME]{Une combinaison de date et heure. L'intervalle de validité va de '1000-01-01 00:00:00' à '9999-12-31 23:59:59'. MySQL affiche les valeurs de type DATE au format 'YYYY-MM-DD HH:MM:SS', mais vous permet d'assigner des valeurs DATE en utilisant plusieurs formats de chaînes et nombres.}
\item[\hspace{1mm} TIMESTAMP\texttt{[}(M)\texttt{]}]{Un timestamp. L'intervalle de validité va de '1970-01-01 00:00:00' à quelque part durant l'année 2037. les valeurs TIMESTAMP sont affichées au format YYYYMMDDHHMMSS, YYMMDDHHMMSS, YYYYMMDD ou YYMMDD, suivant que la valeur de M est 14 (ou absente), 12, 8 ou 6, respectivement, mais vous permet d'assigner des valeurs aux colonnes TIMESTAMP en utilisant des nombres ou des chaînes. TIMESTAMP est retournée comme une chaîne, au format 'YYYY-MM-DD HH:MM:SS'. Si vous voulez que MySQL vous retourne un nombre, ajoutez +0 à la colonne. Les différentes tailles de timestamp ne sont pas supportées.}
\end{description}
 
\hspace{1mm}  Une colonne TIMESTAMP est utile pour enregistrer les dates et heures des opérations INSERT et UPDATE, car elle prend automatiquement date actuellement si vous ne lui assignez pas de valeur par vous-même. Vous pouvez aussi lui donner la valeur courante en lui donnant la valeur NULL. L'argument M affecte l'affichage des colonnes de type TIMESTAMP. ses valeurs sont toujours stockées sur 4 octets. Notez que les colonnes TIMESTAMP(M) où M vaut 8 ou 14 sont indiquée comme étant des nombres, alors que les colonnes TIMESTAMP(M) sont indiquées comme étant des chaînes. Cela est fait pour s'assurer que l'ont peut enregistrer et lire correctement les tables ayant ce type.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} TIME]{Une heure. L'intervalle va de '-838:59:59' à '838:59:59'. MySQL affiche les valeurs TIME au format 'HH:MM:SS', mais vous permet d'assigner des valeurs TIME en utilisant des nombres ou des chaînes.}
\item[\hspace{1mm} YEAR\texttt{[}(2|4)\texttt{]}]{Une année, au format 2 ou 4 chiffres (par défaut, c'est 4 chiffres). Les valeurs possibles vont de 1901 à 2155 plus 0000 pour le format à 4 chiffres, et de 1970 à 2069 si vous utilisez le format à 2 chiffres. MySQL affiche les valeurs YEAR au format YYYY mais vous permet d'assigner des valeurs en utilisant des nombres ou des chaînes.}
\end{description}
 
\vspace{1cm}{\huge Types de colonnes - chaînes }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} CHAR et VARCHAR]{Les types CHAR et VARCHAR sont similaires, mais diffèrent dans la manière dont ils sont stockés et récupérés.}
\end{description}
 
\hspace{1mm}  La longueur d'une colonne CHAR est fixée à la longueur que vous avez défini lors de la création de la table. La longueur peut être n'importe quelle valeur entre 1 et 255. Quand une valeur CHAR est enregistrée, elle est complété à droite avec des espaces jusqu'à atteindre la valeur fixée. Quand une valeur de CHAR est lue, les espaces en trop sont retirés.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les valeurs contenues dans les colonnes de type VARCHAR sont de tailles variables. Vous pouvez déclarer une colonne VARCHAR pour que sa taille soit comprise entre 1 et 255, exactement comme pour les colonnes CHAR. Par contre, contrairement à CHAR, les valeurs de VARCHAR sont stockées en utilisant autant de caractères que nécessaire, plus un octet pour mémoriser la longueur. Les valeurs ne sont pas complétées. Au contraire, les espaces finaux sont supprimés avant stockage. Si vous assignez une chaîne de caractères qui dépasse la capacité de la colonne CHAR ou VARCHAR, celle ci est tronquée jusqu'à la taille maximale du champ.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les valeurs dans les colonnes CHAR et VARCHAR sont classées et comparées sans tenir compte de la casse, à moins que l'attribut BINARY n'ai été spécifié lors de la création de la table. L'attribut BINARY signifie que les valeurs sont classées et triées en tenant compte de la casse, suivant l'ordre des caractères ASCII de la machine ou est installé le serveur MySQL. BINARY n'affecte pas les méthodes de lecture et de stockage des valeurs. L'attribut BINARY se propage dans une expression : il suffit qu'une seule colonne, utilisée dans une expression, ait l'attribut BINARY pour que toute l'expression ne tienne plus compte de la casse.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} BINARY et VARBINARY]{Les types BINARY et VARBINARY sont similaires à CHAR et VARCHAR, hormis le fait qu'ils contiennent des chaînes binaires, plutôt que des chaînes de texte. C'est à dire, qu'ils contiennent des chaînes d'octets, plutôt que des chaînes de caractères. Cela signifie qu'ils n'ont pas de jeu de caractères associé, et les tris et comparaisons sont basées sur la valeur numérique de l'octet. La taille maximale pour les types BINARY et VARBINARY, est la même que celles de CHAR et VARCHAR, hormis le fait que la taille de BINARY et VARBINARY est une taille en octets, et non pas en caractères.}
\item[\hspace{1mm} BLOB et TEXT]{une valeur TEXT est une valeur BLOB insensible à la casse. Pour les index des colonnes BLOB et TEXT, vous devez spécifier une taille d'index. Pour les colonnes de type CHAR et VARCHAR, la taille du préfixe est optionnelle. Il n'y a pas de suppression des espaces finaux lors du stockage de valeur dans des colonnes de type BLOB et TEXT, ce qui est le cas dans pour les colonnes de type VARCHAR. Les colonnes BLOB et TEXT ne peuvent avoir de valeur par défaut. (DEFAULT). Les quatre types BLOB (TINYBLOB, BLOB, MEDIUMBLOB, et LONGBLOB). Les quatre types TEXT (TINYTEXT, TEXT, MEDIUMTEXT, et LONGTEXT)}
\item[\hspace{1mm} ENUM]{Une énumération ENUM est une chaîne dont la valeur est choisie parmi une liste de valeurs autorisées lors de la création de la table. Cette chaîne peut aussi être la chaîne vide ("") ou NULL dans certaines circonstances. Si une colonne d'énumération est déclarée NULL, NULL devient aussi une valeur autorisée, et la valeur par défaut est alors NULL. Si une colonne d'énumération est déclarée NOT NULL, la valeur par défaut est le premier élément de la liste des valeurs autorisées.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{6mm} ]{Chaque élément de l'énumération dispose d'un index.}
\item[\hspace{6mm} -]{Les valeurs de la liste des valeurs autorisées sont indexées à partir de 1.}
\item[\hspace{6mm} -]{L'index de la valeur NULL est NULL.}
\item[\hspace{6mm} -]{Une énumération peut avoir un maximum de 65535 éléments.}
\item[\hspace{6mm} -]{Il est déconseillé de stocker des valeurs numériques dans un ENUM car cela engendre des confusions}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} SET]{Un SET est une chaîne qui peut avoir zéro ou plusieurs valeurs, chacune doit être choisie dans une liste de valeurs définies lors de la création de la table. Les valeurs des colonnes SET composées de plusieurs membres sont définies en séparant celles-ci avec des virgules (‘,’). Ce qui fait que la valeur d'un membre de SET ne peut contenir lui même de virgule. Un SET peut avoir au plus 64 membres.}
\end{description}
 
\hspace{6mm} Par exemple, une colonne définie en tant que SET("un", "deux") NOT NULL peut avoir l'une de ces valeurs: \\
\hspace{6mm} \textbf{""} \\
\hspace{6mm} \textbf{"un"} \\
\hspace{6mm} \textbf{"deux"} \\
\hspace{6mm} \textbf{"un,deux"} \\
 
\vspace{1cm}{\huge Capacité des colonnes numériques }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} Type de colonne/Espace requis]{}
\item[\hspace{1mm} TINYINT]{1 octet}
\item[\hspace{1mm} SMALLINT]{2 octets}
\item[\hspace{1mm} MEDIUMINT]{3 octets}
\item[\hspace{1mm} INT, INTEGER]{4 octets}
\item[\hspace{1mm} BIGINT]{8 octets}
\item[\hspace{1mm} FLOAT(p)]{4 if X <= 24 or 8 if 25 <= X <= 53}
\item[\hspace{1mm} FLOAT]{4 octets}
\item[\hspace{1mm} DOUBLE PRECISION, REAL]{8 octets}
\item[\hspace{1mm} DECIMAL(M,D)]{M+2 octets si D > 0, M+1 octets si D=0 (D+2, si M<D)}
\end{description}
 
\vspace{1cm}{\huge Capacité des colonnes temporelles }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} Type de colonne / Espace requis]{}
\item[\hspace{1mm} DATE]{3 octets}
\item[\hspace{1mm} DATETIME]{8 octets}
\item[\hspace{1mm} TIMESTAMP]{4 octets}
\item[\hspace{1mm} TIME]{3 octets}
\item[\hspace{1mm} YEAR]{1 octet}
\end{description}
 
\vspace{1cm}{\huge Capacité des colonnes texte }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} Type de colonne / Espace requis]{}
\item[\hspace{1mm} CHAR(M)]{M octets, 1 <= M 255}
\item[\hspace{1mm} VARCHAR(M)]{L+1 octets, avec L <= M et 1 <= M <= 255}
\item[\hspace{1mm} TINYBLOB, TINYTEXT]{L+1 octets, avec L < 2\textasciicircum 8}
\item[\hspace{1mm} BLOB, TEXT]{L+2 octets, avec L < 2\textasciicircum 16}
\item[\hspace{1mm} MEDIUMBLOB, MEDIUMTEXT]{L+3 octets, avec L < 2\textasciicircum 24}
\item[\hspace{1mm} LONGBLOB, LONGTEXT]{L+4 octets, avec L < 2\textasciicircum 32}
\item[\hspace{1mm} ENUM('valeur1','valeur2',...)]{1 ou 2 octets, suivant le nombre d'éléments de l'énumération (65535 au maximum)}
\item[\hspace{1mm} SET('valeur1','valeur2',...)]{1, 2, 3, 4 ou 8 octets, suivant le nombre de membres de l'ensemble (64 au maximum)}
\end{description}
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Priorité des opérateurs }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} :=]{}
\item[\hspace{1mm} ||, OR, XOR]{}
\item[\hspace{1mm} \&\&, AND]{}
\item[\hspace{1mm} BETWEEN, CASE, WHEN, THEN, ELSE]{}
\item[\hspace{1mm} =, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN]{}
\item[\hspace{1mm} |]{}
\item[\hspace{1mm} \&]{}
\item[\hspace{1mm} <<, >>]{}
\item[\hspace{1mm} -, +]{}
\item[\hspace{1mm} *, /, DIV, \%, MOD]{}
\item[\hspace{1mm} \textasciicircum]{}
\item[\hspace{1mm} - (unary minus), (unary bit inversion)]{}
\item[\hspace{1mm} NOT, !]{}
\item[\hspace{1mm} BINARY, COLLATE]{}
\end{description}
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Opérateurs de comparaison }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} =]{Egal}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 = 0 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT '0' = 0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT '0.0' = 0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT '0.01' = 0 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT '.01' = 0.01 ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} <=>]{Comparaison compatible avec NULL. Cet opérateur fait une comparaison d'égalité comme l'opérateur =, mais retourne 1 plutôt que NULL si les deux opérandes sont NULL, et 0 plutôt que NULL si un opérande est NULL}
\item[\hspace{1mm} <>, !=]{Différent}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT '.01' <> '0.01' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT .01 <> '0.01' ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'zapp' <> 'zappp' ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} <=]{Inférieur ou égal}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 0.1 <= 2;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} <]{Strictement inférieur}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 2 < 2 ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} >=]{Supérieur ou égal}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 2 >= 2 ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} >]{Strictement supérieur}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 2 > 2 ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} IS NULL, IS NOT NULL]{Tester si une valeur est ou n'est pas NULL}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL ;} \\
\hspace{1mm} \textbf{-> 0 0 1} \\
\hspace{1mm} \textbf{mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL ;} \\
\hspace{1mm} \textbf{-> 1 1 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} expression BETWEEN min AND max]{Si \textbf{expression} est supérieure ou égale à \textbf{min} et \textbf{expression} est inférieure ou égale à \textbf{max}, \textbf{BETWEEN} retourne 1, sinon 0. Ceci est équivalent à l'expression (\textbf{min <= expression AND expression <= max}) si tous les arguments sont du même type. Dans tous les autres cas, la conversion de type prends place, selon les règles suivantes, mais appliquée aux trois arguments.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 BETWEEN 2 AND 3 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'b' BETWEEN 'a' AND 'c' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 2 BETWEEN 2 AND '3' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 2 BETWEEN 2 AND 'x-3' ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} expr NOT BETWEEN min AND max]{Même chose que NOT (expr BETWEEN min AND max). COALESCE(list) Retourne le premier élément non-NULL de la liste}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COALESCE(NULL,1) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT COALESCE(NULL,NULL,NULL) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} GREATEST(value1,value2,...)]{Avec deux ou plusieurs arguments, retourne la valeur la plus grande. Les arguments sont comparés en utilisant les mêmes règles que pour LEAST()}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT GREATEST(2,0) ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT GREATEST(34.0,3.0,5.0,767.0) ;} \\
\hspace{1mm} \textbf{-> 767.0} \\
\hspace{1mm} \textbf{mysql> SELECT GREATEST('B','A','C') ;} \\
\hspace{1mm} \textbf{-> 'C'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} expr IN (valeur,...)]{Retourne 1 si \textbf{expr} est l'une des valeurs dans la liste \textbf{IN}, sinon retourne 0. Si toutes les valeurs sont des constantes, toutes les valeurs sont évaluées avec le type de \textbf{expr} et triées. La recherche de l'élément est alors faite en utilisant la recherche binaire. Cela signifie que \textbf{IN} est très rapide si les valeurs contenues dans la liste \textbf{IN} sont toutes des constantes. Si \textbf{expr} est une chaîne sensible à la casse, la comparaison est faite dans un contexte sensible à la casse:}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 2 IN (0,3,5,'wefwf') ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'wefwf' IN (0,3,5,'wefwf') ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} expr NOT IN (value,...)]{Même chose que NOT (expr IN (valeur,...)).}
\item[\hspace{1mm} ISNULL(expr) Si expr est NULL, ISNULL()]{retourne 1, sinon il retourne 0}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ISNULL(1+1) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT ISNULL(1/0) ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\hspace{1mm}  Notez que la comparaison de deux valeurs NULL en utilisant = donnera toujours false !
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} INTERVAL(N,N1,N2,N3,...)]{Retourne 0 si N < N1, 1 si N < N2 etc... Tous les arguments sont traités en tant qu'entiers. Il est requis que N1 < N2 < N3 < ... < Nn pour que cette fonction fonctionne correctement. Cela est due à la recherche binaire utilisée (très rapide)}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200) ;} \\
\hspace{1mm} \textbf{-> 3} \\
\hspace{1mm} \textbf{mysql> SELECT INTERVAL(10, 1, 10, 100, 1000) ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT INTERVAL(22, 23, 30, 44, 200) ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LEAST(value1,value2,...)]{Avec deux arguments ou plus, retourne la plus petite valeur.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LEAST(2,0) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT LEAST(34.0,3.0,5.0,767.0) ;} \\
\hspace{1mm} \textbf{-> 3.0} \\
\hspace{1mm} \textbf{mysql> SELECT LEAST('B','A','C') ;} \\
\hspace{1mm} \textbf{-> 'A'} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Opérateurs logiques }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} NOT, !]{(NON) logique. Évalue à 1 si l'opérande est 0, à 0 si l'opérande est non nulle, et NOT NULL retourne NULL. Le dernier exemple donne 1 car l'expression est évaluée comme (!1)+1}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT NOT 10 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT NOT 0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT NOT NULL ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT ! (1+1) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT ! 1+1 ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} AND, \&\&]{(ET) logique. Évalue à 1 si toutes les opérandes sont différentes de zéro et de NULL, à 0 si l'une des opérandes est 0, dans les autres cas, NULL est retourné.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 \&\& 1 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 1 \&\& 0 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 1 \&\& NULL ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT 0 \&\& NULL ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT NULL \&\& 0 ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\hspace{1mm}  Notez que pour les versions antérieures à la 4.0.5 l'évaluation est interrompue lorsque NULL est rencontré, au lieu de continuer à tester une éventuelle existence de 0. Cela signifie que dans ces versions, SELECT (NULL AND 0) retourne NULL au lieu de 0. En 4.0.5 le code a été revu pour que le résultat réponde toujours au normes ANSI tout en optimisant le plus possible.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} OR, ||]{(OU inclusif) logique. Évalue à 1 si aucune opérande n'est nulle, à NULL si l'une des opérandes est NULL, sinon 0 est retourné.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 || 1 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 1 || 0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 0 || 0 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 0 || NULL ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT 1 || NULL ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} XOR]{(OU exclusif) logique. Retourne NULL si l'une des opérandes est NULL. Pour les opérandes non-NULL, évalue à 1 si un nombre pair d'opérandes est non-nul, sinon 0 est retourné. a XOR b est mathématiquement égal à (a AND (NOT b)) OR ((NOT a) and b).}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 XOR 1 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 1 XOR 0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 1 XOR NULL ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT 1 XOR 1 XOR 1 ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions de contrôle }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} IFNULL(expr1,expr2)]{Si l'argument expr1 n'est pas NULL, la fonction IFNULL() retournera l'argument expr1, sinon elle retournera l'argument expr2. La fonction IFNULL() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT IFNULL(1,0) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT IFNULL(NULL,10) ;} \\
\hspace{1mm} \textbf{-> 10} \\
\hspace{1mm} \textbf{mysql> SELECT IFNULL(1/0,10) ;} \\
\hspace{1mm} \textbf{-> 10} \\
\hspace{1mm} \textbf{mysql> SELECT IFNULL(1/0,'oui') ;} \\
\hspace{1mm} \textbf{-> 'oui'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} NULLIF(expr1,expr2)]{Si l'expression expr1 = expr2 est vrai, la fonction retourne NULL sinon elle retourne expr1. Cela revient à faire CASE WHEN x = y THEN NULL ELSE x END}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT NULLIF(1,1) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT NULLIF(1,2) ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} IF(expr1,expr2,expr3)]{Si l'argument expr1 vaut TRUE (expr1 <> 0 et expr1 <> NULL) alors la fonction IF() retourne l'argument expr2, sinon, elle retourne l'argument expr3. La fonction IF() retourne une valeur numérique ou une chaîne de caractères, suivant le contexte d'utilisation}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT IF(1>2,2,3) ;} \\
\hspace{1mm} \textbf{-> 3} \\
\hspace{1mm} \textbf{mysql> SELECT IF(1<2,'oui','non') ;} \\
\hspace{1mm} \textbf{-> 'oui'} \\
\hspace{1mm} \textbf{mysql> SELECT IF(STRCMP('test','test1'),'non','oui') ;} \\
\hspace{1mm} \textbf{-> 'non'} \\
 
\hspace{1mm}  Si l'argument expr2 ou expr3 est explicitement NULL alors le type du résultat de la fonction IF() est le type de la colonne non NULL. L'argument expr1 est évalué comme un entier, cela signifie que si vous testez un nombre à virgule flottante ou une chaîne de caractères, vous devez utiliser une opération de comparaison
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT IF(0.1,1,0) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT IF(0.1<>0,1,0) ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CASE valeur WHEN \texttt{[}compare-value\texttt{]} THEN résultat \texttt{[}WHEN \texttt{[}compare-value\texttt{]} THEN résultat ...\texttt{]} \texttt{[}ELSE résultat\texttt{]} END,]{}
\item[\hspace{1mm} CASE WHEN \texttt{[}condition\texttt{]} THEN résultat \texttt{[}WHEN \texttt{[}condition\texttt{]} THEN résultat ...\texttt{]} \texttt{[}ELSE résultat\texttt{]} END]{}
\item[\hspace{1mm} ]{La première version retourne résultat si valeur=compare-value. La seconde version retourne le résultat de la première condition qui se réalise. Si aucune des conditions n'est réalisé, alors le résultat de la clause ELSE est retourné. Si il n'y a pas de clause ELSE alors NULL est retourné. Le type de la valeur retournée (INTEGER, DOUBLE ou STRING) est de même type que la première valeur retournée (l'expression après le premier THEN).}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CASE 1 WHEN 1 THEN "un"} \\
\hspace{1mm} \textbf{WHEN 2 THEN "deux" ELSE "plus" END ;} \\
\hspace{1mm} \textbf{-> "un"} \\
\hspace{1mm} \textbf{mysql> SELECT CASE WHEN 1>0 THEN "vrai" ELSE "faux" END ;} \\
\hspace{1mm} \textbf{-> "vrai"} \\
\hspace{1mm} \textbf{mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions de chaînes de caractères }
 
\
 
\hspace{1mm}  Les fonctions qui traitent les chaînes de caractères retournent NULL si la longueur du résultat finit par dépasser la taille maximale du paramètre max\_allowed\_packet, défini dans la configuration du serveur.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} ASCII(str)]{Retourne le code ASCII du premier caractère de la chaîne de caractères str. Retourne 0 si la chaîne de caractère str est vide. Retourne NULL si la chaîne de caractères str est NULL. ASCII() fonctionne avec des valeurs numériques entre 0 et 255. Voir aussi la fonction ORD().}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ASCII('2') ;} \\
\hspace{1mm} \textbf{-> 50} \\
\hspace{1mm} \textbf{mysql> SELECT ASCII(2) ;} \\
\hspace{1mm} \textbf{-> 50} \\
\hspace{1mm} \textbf{mysql> SELECT ASCII('dx') ;} \\
\hspace{1mm} \textbf{-> 100} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} BIN(N)]{Retourne une chaîne de caractères représentant la valeur binaire de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,2). Retourne NULL si l'argument N est NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT BIN(12) ;} \\
\hspace{1mm} \textbf{-> '1100'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} BIT\_LENGTH(str)]{Retourne le nombre de bits de la chaîne de caractères str.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT BIT\_LENGTH('text') ;} \\
\hspace{1mm} \textbf{-> 32} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CHAR(N,...)]{La fonction CHAR() interprète les arguments comme des entiers et retourne une chaîne de caractères, constituée des caractères, identifiés par leur code ASCII. Les valeurs NULL sont ignorées}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CHAR(77,121,83,81,'76') ;} \\
\hspace{1mm} \textbf{-> 'MySQL'} \\
\hspace{1mm} \textbf{mysql> SELECT CHAR(77,77.3,'77.3') ;} \\
\hspace{1mm} \textbf{-> 'MMM'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CHAR\_LENGTH(str)]{Retourne le nombre de caractères de la chaîne str: Un caractère multi-octets compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR\_LENGTH() retournera 5.}
\item[\hspace{1mm} CHARACTER\_LENGTH(str)]{est un synonyme de CHAR\_LENGTH()}
\item[\hspace{1mm} COMPRESS(string\_to\_compress)]{Compresse une chaîne. Cette fonction requiert la présence de la bibliothèque zlib. Sinon, la valeur retournée sera toujours NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000))) ;} \\
\hspace{1mm} \textbf{-> 21} \\
\hspace{1mm} \textbf{mysql> SELECT LENGTH(COMPRESS('')) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT LENGTH(COMPRESS('a')) ;} \\
\hspace{1mm} \textbf{-> 13} \\
\hspace{1mm} \textbf{mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16))) ;} \\
\hspace{1mm} \textbf{-> 15} \\
 
\hspace{1mm}  La chaîne compressée est stockée de cette manière: Les chaînes vides sont stockées comme des chaînes vides; Les chaînes non-vides sont stockées avec 4 octets de plus, indiquant la taille de la chaîne non compressée, suivie de la chaîne compressée. Si la chaîne se termine avec des espaces, un point supplémentaire "." est ajouté, pour éviter que les espaces terminaux soient supprimés de la chaîne. N'utilisez pas les types CHAR ou VARCHAR pour stocker des chaînes compressée. Il est mieux d'utiliser un type BLOB.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} CONCAT\_WS(separator, str1, str2,...)]{La fonction CONCAT\_WS() signifie CONCAT With Separator, c'est-à-dire "concaténation avec séparateur". Le premier argument est le séparateur utilisé pour le reste des arguments. Le séparateur peut être une chaîne de caractères, tout comme le reste des arguments. Si le séparateur est NULL, le résultat sera NULL. Cette fonction ignorera tous les arguments de valeur NULL et vides, hormis le séparateur. Le séparateur sera ajouté entre tous les arguments à concaténer}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CONCAT\_WS(",","Premier nom","Deuxième nom","Dernier nom");} \\
\hspace{1mm} \textbf{-> 'Premier nom,Deuxième nom,Dernier nom'} \\
\hspace{1mm} \textbf{mysql> SELECT CONCAT\_WS(",","Premier nom",NULL,"Dernier nom") ;} \\
\hspace{1mm} \textbf{-> 'Premier nom,Dernier nom'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CONV(N,from\_base,to\_base)]{Convertit des nombres entre différentes bases. Retourne une chaîne de caractères représentant le nombre N, convertit de la base from\_base vers la base to\_base. La fonction retourne NULL si un des arguments est NULL. L'argument N est interprété comme un entier, mais peut être spécifié comme un entier ou une chaîne de caractères. Le minimum pour la base est 2 et son maximum est 36. Si to\_base est un nombre négatif, N sera considéré comme un nombre signé. Dans le cas contraire, N sera traité comme un nombre non-signé. La fonction CONV travaille avec une précision de 64 bits}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CONV("a",16,2) ;} \\
\hspace{1mm} \textbf{-> '1010'} \\
\hspace{1mm} \textbf{mysql> SELECT CONV("6E",18,8) ;} \\
\hspace{1mm} \textbf{-> '172'} \\
\hspace{1mm} \textbf{mysql> SELECT CONV(-17,10,-18) ;} \\
\hspace{1mm} \textbf{-> '-H'} \\
\hspace{1mm} \textbf{mysql> SELECT CONV(10+"10"+'10'+0xa,10,10) ;} \\
\hspace{1mm} \textbf{-> '40'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ELT(N,str1,str2,str3,...)]{Retourne str1 si N = 1, str2 si N = 2, et ainsi de suite. Retourne NULL si N est plus petit que 1 ou plus grand que le nombre d'arguments. La fonction ELT() est un complément de la fonction FIELD()}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo') ;} \\
\hspace{1mm} \textbf{-> 'ej'} \\
\hspace{1mm} \textbf{mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo') ;} \\
\hspace{1mm} \textbf{-> 'foo'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} EXPORT\_SET(bits,on,off,\texttt{[}séparateur,\texttt{[}nombre\_de\_bits\texttt{]}\texttt{]})]{Retourne une chaîne dont tous les bits à 1 dans "bit" sont représentés par la chaîne "on", et dont tous les bits à 0 sont représentés par la chaîne "off". Chaque chaîne est séparée par 'séparateur' (par défaut, une virgule ‘','’) et seul "nombre\_de\_bits" (par défaut, 64) "bits" est utilisé}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT EXPORT\_SET(5,'Y','N',',',4)} \\
\hspace{1mm} \textbf{-> Y,N,Y,N} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FIELD(str,str1,str2,str3,...)]{Retourne l'index de la chaîne str dans la liste str1, str2, str3, .... Retourne 0 si str n'est pas trouvé. La fonction FIELD() est un complément de la fonction ELT()}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo') ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FIND\_IN\_SET(str,strlist)]{Retourne une valeur de 1 à N si la chaîne str se trouve dans la liste strlist constituée de N chaînes. Une liste de chaîne est une chaîne composée de sous-chaînes séparées par une virgule ‘,’. Si le premier argument est une chaîne constante et le second, une colonne de type SET, la fonction FIND\_IN\_SET() est optimisée pour utiliser une recherche binaire très rapide. Retourne 0 si str n'est pas trouvé dans la liste strlist ou si la liste strlist est une chaîne vide. Retourne NULL si l'un des arguments est NULL. Cette fonction ne fonctionne pas correctement si le premier argument contient une virgule ','}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FIND\_IN\_SET('b','a,b,c,d') ;} \\
\hspace{1mm} \textbf{-> 2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} HEX(N\_or\_S)]{Si l'argument N\_OR\_S est un nombre, cette fonction retournera une chaîne de caractère représentant la valeur hexadécimale de l'argument N, où l'argument N est de type BIGINT. Cette fonction est un équivalent de CONV(N,10,16). Si N\_OR\_S est une chaîne de caractères, cette fonction retournera une chaîne de caractères hexadécimale de N\_OR\_S où chaque caractère de N\_OR\_S est converti en 2 chiffres hexadécimaux. C'est l'inverse de la chaîne 0xff.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT HEX(255) ;} \\
\hspace{1mm} \textbf{-> 'FF'} \\
\hspace{1mm} \textbf{mysql> SELECT HEX("abc") ;} \\
\hspace{1mm} \textbf{-> 616263} \\
\hspace{1mm} \textbf{mysql> SELECT 0x616263 ;} \\
\hspace{1mm} \textbf{-> "abc"} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} INSERT(str,pos,len,newstr)]{Retourne une chaîne de caractères str, après avoir remplacé la portion de chaîne commençant à la position pos et de longueur len caractères, par la chaîne newstr. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT INSERT('Quadratic', 3, 4, 'What') ;} \\
\hspace{1mm} \textbf{-> 'QuWhattic'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} INSTR(str,substr)]{Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Cette fonction est exactement la même que la fonction LOCATE(), à la différence que ces arguments sont inversés. Cette fonction gère les caractères multi-octets. cette fonction sera sensible à la casse si l'argument est une chaîne de caractères binaire.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT INSTR('foobarbar', 'bar') ;} \\
\hspace{1mm} \textbf{-> 4} \\
\hspace{1mm} \textbf{mysql> SELECT INSTR('xbar', 'foobar') ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LCASE(str)]{est un synonyme de LOWER().}
\item[\hspace{1mm} LEFT(str,len)]{Retourne les len caractères les plus à gauche de la chaîne de caractères str. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LEFT('foobarbar', 5) ;} \\
\hspace{1mm} \textbf{-> 'fooba'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LENGTH(str)]{Retourne la taille de la chaîne str, mesurée en octets. Un caractère multi-octets compte comme un seul caractère. Cela signifie que pour une chaîne contenant 5 caractères de 2 octets, LENGTH() retournera 10, alors que CHAR\_LENGTH() retournera 5.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LENGTH('text') ;} \\
\hspace{1mm} \textbf{-> 4} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOAD\_FILE(file\_name)]{Lit le fichier file\_name et retourne son contenu sous la forme d'une chaîne de caractères. Le fichier doit se trouver sur le serveur qui exécute MySQL, vous devez spécifier le chemin absolu du fichier et vous devez avoir les droits en lecture sur celui-ci. Le fichier doit pouvoir être lisible par tous et doit être plus petit que max\_allowed\_packet. Si ce fichier n'existe pas ou ne peut pas être lu pour différentes raisons, la fonction retourne NULL}
\end{description}
 
\hspace{1mm} \textbf{mysql> UPDATE tbl\_name} \\
\hspace{1mm} \textbf{SET blob\_column=LOAD\_FILE("/tmp/picture")} \\
\hspace{1mm} \textbf{WHERE id=1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOCATE(substr,str), LOCATE(substr,str,pos)]{Retourne la position de la première occurrence de la chaîne substr dans la chaîne de caractères str. Retourne 0 si substr ne se trouve pas dans la chaîne de caractères str. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LOCATE('bar', 'foobarbar') ;} \\
\hspace{1mm} \textbf{-> 4} \\
\hspace{1mm} \textbf{mysql> SELECT LOCATE('xbar', 'foobar') ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT LOCATE('bar', 'foobarbar',5) ;} \\
\hspace{1mm} \textbf{-> 7} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOWER(str)]{Retourne la chaîne str avec tous les caractères en minuscules, en fonction du jeu de caractères courant (par défaut, c'est le jeu ISO-8859-1 Latin1). Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LOWER('QUADRATIQUE') ;} \\
\hspace{1mm} \textbf{-> 'quadratique'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LPAD(str,len,padstr)]{Retourne la chaîne de caractères str, complétée à gauche par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len' caractères, elle sera raccourcie de len caractères.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LPAD('hi',4,' ??') ;} \\
\hspace{1mm} \textbf{-> ' ??hi'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LTRIM(str)]{Retourne la chaîne de caractères str sans les espaces initiaux}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LTRIM(' barbar') ;} \\
\hspace{1mm} \textbf{-> 'barbar'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MAKE\_SET(bits,str1,str2,...)]{Retourne une liste (une chaîne contenant des sous-chaînes séparées par une virgule ‘,’) constituée de chaînes qui ont le bit correspondant dans la liste bits. str1 correspond au bit 0, str2 au bit 1, etc... Les chaînes NULL dans les listes str1, str2, ... sont ignorées}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MAKE\_SET(1,'a','b','c') ;} \\
\hspace{1mm} \textbf{-> 'A'} \\
\hspace{1mm} \textbf{mysql> SELECT MAKE\_SET(1 | 4,'hello','nice','world') ;} \\
\hspace{1mm} \textbf{-> 'hello,world'} \\
\hspace{1mm} \textbf{mysql> SELECT MAKE\_SET(0,'a','b','c') ;} \\
\hspace{1mm} \textbf{-> ''} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MID(str,pos,len)]{est un synonyme de SUBSTRING(str,pos,len).}
\item[\hspace{1mm} OCT(N)]{Retourne une chaîne de caractères représentant la valeur octal de l'argument N, où l'argument N est un nombre de type BIGINT. Cette fonction est un équivalent de CONV(N,10,8). Retourne NULL si l'argument N est NULL}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT OCT(12) ;} \\
\hspace{1mm} \textbf{-> '14'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} OCTET\_LENGTH(str)]{est un synonyme de LENGTH().}
\item[\hspace{1mm} ORD(str)]{Si le premier caractère de la chaîne str est un caractère multi-octets, la fonction retourne le code de ce caractère, calculé à partir du code ASCII retourné par cette formule}
\end{description}
 
\hspace{1mm} \textbf{(1st octet * 256)} \\
\hspace{1mm} \textbf{+ (2nd octet * 256\textasciicircum 2)} \\
\hspace{1mm} \textbf{+ (3rd octet * 256\textasciicircum 3) ...} \\
\hspace{1mm} Si le premier caractère n'est pas un caractère multi-octet, la fonction retournera la même valeur que la fonction ASCII() \\
\hspace{1mm} \textbf{mysql> SELECT ORD('2') ;} \\
\hspace{1mm} \textbf{-> 50} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} POSITION(substr IN str)]{est un synonyme de LOCATE(substr,str).}
\item[\hspace{1mm} QUOTE(str)]{Échappe les caractères d'une chaîne pour produire un résultat qui sera exploitable dans une requête SQL. Les caractères suivants seront précédés d'un anti-slash dans la chaîne retournée : le guillemet simple (‘'’), l'anti-slash (‘\textbackslash{}’), ASCII NUL, et le Contrôle-Z. Si l'argument vaut NULL, la valeur retournée sera le mot ``NULL'' sans les guillemets simples.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT QUOTE("Don't") ;} \\
\hspace{1mm} \textbf{-> 'Don\textbackslash{}'t !'} \\
\hspace{1mm} \textbf{mysql> SELECT QUOTE(NULL) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} REPEAT(str,count)]{Retourne une chaîne de caractères constituée de la répétition de count fois la chaîne str. Si count <= 0, retourne une chaîne vide. Retourne NULL si str ou count sont NULL}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT REPEAT('MySQL', 3) ;} \\
\hspace{1mm} \textbf{-> 'MySQLMySQLMySQL'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} REPLACE(str,from\_str,to\_str)]{Retourne une chaîne de caractères str dont toutes les occurrences de la chaîne from\_str sont remplacées par la chaîne to\_str. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT REPLACE('www.mysql.com\&\#39 ;, 'w', 'Ww') ;} \\
\hspace{1mm} \textbf{-> 'WwWwWw.mysql.com\&\#39 ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} REVERSE(str)]{Retourne une chaîne dont l'ordre des caractères est l'inverse de la chaîne str. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT REVERSE('abc') ;} \\
\hspace{1mm} \textbf{-> 'cba'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} RIGHT(str,len)]{Retourne les len caractères les plus à droite de la chaîne de caractères str. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT RIGHT('foobarbar', 4) ;} \\
\hspace{1mm} \textbf{-> 'rbar'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} RPAD(str,len,padstr)]{Retourne la chaîne de caractères str, complétée à droite par la chaîne de caractères padstr jusqu'à ce que la chaîne de caractères str atteigne len caractères de long. Si la chaîne de caractères str est plus longue que len' caractères, elle sera raccourcie de len caractères.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT RPAD('hi',5,' ?') ;} \\
\hspace{1mm} \textbf{-> 'hi ???'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} RTRIM(str)]{Retourne la chaîne de caractères str sans les espaces finaux. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT RTRIM('barbar ') ;} \\
\hspace{1mm} \textbf{-> 'barbar'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SOUNDEX(str)]{Retourne la valeur Soundex de la chaîne de caractères str. Deux chaînes qui ont des sonorités proches auront des valeurs soundex proches. Une chaîne Soundex standard possède 4 caractères, mais la fonction SOUNDEX() retourne une chaîne de longueur arbitraire. Vous pouvez utiliser la fonction SUBSTRING() sur ce résultat pour obtenir une chaîne Soundex standard. Tout caractère non alpha-numérique sera ignoré. Tous les caractères internationaux qui ne font pas partie de l'alphabet de base (A-Z) seront considérés comme des voyelles}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SOUNDEX('Hello') ;} \\
\hspace{1mm} \textbf{-> 'H400'} \\
\hspace{1mm} \textbf{mysql> SELECT SOUNDEX('Quadratically') ;} \\
\hspace{1mm} \textbf{-> 'Q36324'} \\
\hspace{1mm} \textbf{expr1 SOUNDS LIKE expr2} \\
\hspace{1mm} Identique à \\
\hspace{1mm} \textbf{SOUNDEX(expr1)=SOUNDEX(expr2)} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SPACE(N) Retourne une chaîne constituée de N espaces]{}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SPACE(6) ;} \\
\hspace{1mm} \textbf{-> ' '} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)]{Retourne une chaîne de len caractères de long de la chaîne str, à partir de la position pos. La syntaxe ANSI SQL92 utilise une variante de la fonction FROM. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SUBSTRING('Quadratically',5) ;} \\
\hspace{1mm} \textbf{-> 'ratically'} \\
\hspace{1mm} \textbf{mysql> SELECT SUBSTRING('foobarbar' FROM 4) ;} \\
\hspace{1mm} \textbf{-> 'barbar'} \\
\hspace{1mm} \textbf{mysql> SELECT SUBSTRING('Quadratically',5,6) ;} \\
\hspace{1mm} \textbf{-> 'ratica'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SUBSTRING\_INDEX(str,delim,count)]{Retourne une portion de la chaîne de caractères str, située avant count occurrences du délimiteur delim. Si l'argument count est positif, tout ce qui précède le délimiteur final sera retourné. Si l'argument count est négatif, tout ce qui suit le délimiteur final sera retourné. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SUBSTRING\_INDEX('www.mysql.com\&\#39 ;, '.', 2) ;} \\
\hspace{1mm} \textbf{-> 'www.mysql\&\#39 ;} \\
\hspace{1mm} \textbf{mysql> SELECT SUBSTRING\_INDEX('www.mysql.com\&\#39 ;, '.', -2) ;} \\
\hspace{1mm} \textbf{-> 'mysql.com'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TRIM(\texttt{[}\texttt{[}BOTH | LEADING | TRAILING\texttt{]} \texttt{[}remstr\texttt{]} FROM\texttt{]} str)]{Retourne la chaîne de caractères str dont tous les préfixes et/ou suffixes remstr ont été supprimés. Si aucun des spécificateurs BOTH, LEADING ou TRAILING sont fournis, BOTH est utilisé comme valeur par défaut. Si remstr n'est pas spécifié, les espaces sont supprimés. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TRIM(' bar ') ;} \\
\hspace{1mm} \textbf{-> 'bar'} \\
\hspace{1mm} \textbf{mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx') ;} \\
\hspace{1mm} \textbf{-> 'barxxx'} \\
\hspace{1mm} \textbf{mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx') ;} \\
\hspace{1mm} \textbf{-> 'bar'} \\
\hspace{1mm} \textbf{mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz') ;} \\
\hspace{1mm} \textbf{-> 'barx'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UCASE(str)]{UCASE() est un synonyme de UPPER()}
\item[\hspace{1mm} UNCOMPRESS(string\_to\_uncompress)]{Décompresse une chaîne compressée avec COMPRESS(). Si l'argument n'est pas une valeur compressée, le résultat est NULL. Cette fonction requiert la bibliothèque zlib. Sinon, la valeur retournée est toujours NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UNCOMPRESS(COMPRESS('any string')) ;} \\
\hspace{1mm} \textbf{-> 'any string'} \\
\hspace{1mm} \textbf{mysql> SELECT UNCOMPRESS('any string') ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UNCOMPRESSED\_LENGTH(compressed\_string)]{Retourne la taille de la chaîne avant compression.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UNCOMPRESSED\_LENGTH(COMPRESS(REPEAT('a',30)));} \\
\hspace{1mm} \textbf{-> 30} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UNHEX(str)]{Le contraire de HEX(string). C'est à dire, chaque paire de chiffres hexadécimaux sont interprétées comme des nombres, et sont convertis en un caractère représenté par le nombre. Le résultat est retournée sous forme de chaîne binaire.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UNHEX('4D7953514C') ;} \\
\hspace{1mm} \textbf{-> 'MySQL'} \\
\hspace{1mm} \textbf{mysql> SELECT 0x4D7953514C ;} \\
\hspace{1mm} \textbf{-> 'MySQL'} \\
\hspace{1mm} \textbf{mysql> SELECT UNHEX(HEX('string')) ;} \\
\hspace{1mm} \textbf{-> 'string'} \\
\hspace{1mm} \textbf{mysql> SELECT HEX(UNHEX('1267')) ;} \\
\hspace{1mm} \textbf{-> '1267'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UPPER(str)]{Retourne la chaîne str en majuscules, en fonction du jeu de caractères courant. Par défaut, c'est le jeu ISO-8859-1 Latin1. Cette fonction gère les caractères multi-octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UPPER('Hey') ;} \\
\hspace{1mm} \textbf{-> 'HEY'} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Opérateurs de comparaison de chaînes de caractères }
 
\
 
\hspace{1mm}  \textbf{MySQL} convertit automatiquement les nombres en chaînes et et vice-versa. Si vous devez convertir explicitement un nombre en chaîne, passez-le en argument de la fonction \textbf{CONCAT()} ou \textbf{CAST()}
\vspace{5mm} \\
\hspace{1mm}  \textbf{expr LIKE pat [ESCAPE 'escape-char']}
\vspace{5mm} \\
\hspace{1mm}  La réalisation d'expressions utilisant les expressions régulières simples de comparaison de SQL retourne 1 (TRUE) ou 0 (FALSE). Avec \textbf{LIKE}, vous pouvez utiliser les deux jokers suivants:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} \%]{Remplace n'importe quel nombre de caractères, y compris aucun}
\item[\hspace{1mm} \_]{Remplace exactement un caractère}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 'David !' LIKE 'David\_' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 'David !' LIKE '\%D\%v\%' ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\hspace{1mm}  Pour tester la présence littérale d'un joker, précédez-le d'un caractère d'échappement. Si vous ne spécifiez pas le caractère d'échappement \textbf{ESCAPE}, le caractère "\textbackslash{}" sera utilisé:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} \textbackslash{}\%]{Remplace le caractère littéral '\%'}
\item[\hspace{1mm} \textbackslash{}\_]{Remplace le caractère littéral '\_'}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 'David !' LIKE 'David\textbackslash{}\_' ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'David\_' LIKE 'David\textbackslash{}\_' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} Pour spécifier un caractère d'échappement différent, utilisez la clause ESCAPE: \\
\hspace{1mm} \textbf{mysql> SELECT 'David\_' LIKE 'David|\_' ESCAPE '|' ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\hspace{1mm}  Les deux exemples suivants illustrent le fait que les comparaisons de chaînes de caractères ne sont pas sensibles à la casse à moins qu'une des opérandes soit une chaîne binaire.
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT 'abc' LIKE 'ABC' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 'abc' LIKE BINARY 'ABC' ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\hspace{1mm}  \textbf{LIKE} est également autorisé pour les expressions numériques. (C'est une extension MySQL à la norme ANSI SQL LIKE.)
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT 10 LIKE '1\%' ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} expr NOT LIKE pat \texttt{[}ESCAPE 'escape-char'\texttt{]}]{Équivalent à \textbf{NOT (expr LIKE pat [ESCAPE 'escape-char'])}.}
\item[\hspace{1mm} expr NOT REGEXP pat, expr NOT RLIKE pat]{Équivalent à \textbf{NOT (expr REGEXP pat)}.}
\item[\hspace{1mm} expr REGEXP pat, expr RLIKE pat]{Effectue une recherche de chaîne avec l'expression régulière \textbf{pat}. Le masque peut être une expression régulière étendue. Retourne 1 si \textbf{expr} correspond au masque \textbf{pat}, sinon, retourne 0. \textbf{RLIKE} est un synonyme de \textbf{REGEXP}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 'Monty !' REGEXP 'm\%y\%\%' ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'Monty !' REGEXP '.*' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 'new*\textbackslash{}n*line' REGEXP 'new\textbackslash{}\textbackslash{}*.\textbackslash{}\textbackslash{}*line' ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A' ;} \\
\hspace{1mm} \textbf{-> 1 0} \\
\hspace{1mm} \textbf{mysql> SELECT 'a' REGEXP '\textasciicircum [a-d]' ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} STRCMP(expr1,expr2) STRCMP()]{retourne 0 si les chaînes sont identiques, -1 si la première chaîne est plus petite que la seconde et 1 dans les autres cas:}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT STRCMP('text', 'text2') ;} \\
\hspace{1mm} \textbf{-> -1} \\
\hspace{1mm} \textbf{mysql> SELECT STRCMP('text2', 'text') ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT STRCMP('text', 'text') ;} \\
\hspace{1mm} \textbf{-> 0} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions numériques }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} Opérations arithmétiques]{}
\item[\hspace{1mm} +]{Addition}
\item[\hspace{1mm} -]{Soustraction}
\item[\hspace{1mm} -]{Moins unaire.}
\item[\hspace{1mm} * ]{Multiplication}
\item[\hspace{1mm} /]{Division}
\item[\hspace{1mm} DIV]{Division entière}
\end{description}
 
\hspace{1mm}  \textbf{Fonctions mathématiques}
\vspace{5mm} \\
\hspace{1mm}  Toutes les fonctions mathématiques retournent \textbf{NULL} en cas d'erreur.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} ABS(X)]{Retourne la valeur absolue de X. Cette fonction est utilisable avec les valeurs issues des champs BIGINT.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ABS(2) ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT ABS(-32) ;} \\
\hspace{1mm} \textbf{-> 32} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ACOS(X)]{Retourne l'arc cosinus de X, c'est à dire, la valeur de l'angle dont X est la cosinus. Retourne NULL si X n'est pas dans l'intervalle -1 - 1.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ACOS(1) ;} \\
\hspace{1mm} \textbf{-> 0.000000} \\
\hspace{1mm} \textbf{mysql> SELECT ACOS(1.0001) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT ACOS(0) ;} \\
\hspace{1mm} \textbf{-> 1.570796} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ASIN(X)]{Retourne l'arc sinus de \textbf{X}, c'est à dire, la valeur de l'angle dont le sinus est \textbf{X}. Retourne NULL si X n'est pas dans l'intervalle -1 - 1}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ASIN(0.2) ;} \\
\hspace{1mm} \textbf{-> 0.201358} \\
\hspace{1mm} \textbf{mysql> SELECT ASIN('foo') ;} \\
\hspace{1mm} \textbf{-> 0.000000} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ATAN(X)]{Retourne l'arc tangente de \textbf{X}, c'est à dire, la valeur de l'angle dont la tangente est X.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ATAN(2) ;} \\
\hspace{1mm} \textbf{-> 1.107149} \\
\hspace{1mm} \textbf{mysql> SELECT ATAN(-2) ;} \\
\hspace{1mm} \textbf{-> -1.107149} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ATAN(Y,X), ATAN2(Y,X)]{Retourne l'arctangente des variables X et Y. Cela revient à calculer l'arctangente de Y / X, excepté que les signes des deux arguments servent à déterminer le quadrant du résultat}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ATAN(-2,2) ;} \\
\hspace{1mm} \textbf{-> -0.785398} \\
\hspace{1mm} \textbf{mysql> SELECT ATAN2(PI(),0) ;} \\
\hspace{1mm} \textbf{-> 1.570796} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CEILING(X), CEIL(X]{Retourne la valeur entière supérieure de X. Notez que la valeur retournée sera de type BIGINT}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CEILING(1.23) ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT CEILING(-1.23) ;} \\
\hspace{1mm} \textbf{-> -1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} COS(X)]{Retourne le cosinus de X, où X est donné en radians.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COS(PI()) ;} \\
\hspace{1mm} \textbf{-> -1.000000} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} COT(X)]{Retourne la cotangente de X.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COT(12) ;} \\
\hspace{1mm} \textbf{-> -1.57267341} \\
\hspace{1mm} \textbf{mysql> SELECT COT(0) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CRC32(expr)]{Calcule la somme de contrôle et retourne un entier 32 bits non-signé. Le résultat est la valeur NULL si l'argument est NULL. L'argument attendu est une chaîne, et sera traité comme une chaîne s'il n'est pas du bon type.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CRC32('MySQL') ;} \\
\hspace{1mm} \textbf{-> 3259397556} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DEGREES(X)]{Retourne l'argument X, convertit de radians en degrés.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DEGREES(PI()) ;} \\
\hspace{1mm} \textbf{-> 180.000000} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} EXP(X)]{Retourne la valeur de e (la base des logarithmes naturels) élevé à la puissance X.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT EXP(2) ;} \\
\hspace{1mm} \textbf{-> 7.389056} \\
\hspace{1mm} \textbf{mysql> SELECT EXP(-2) ;} \\
\hspace{1mm} \textbf{-> 0.135335} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FLOOR(X)]{Retourne la valeur entière inférieure de X. Notez que la valeur retournée sera de type BIGINT}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FLOOR(1.23) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT FLOOR(-1.23) ;} \\
\hspace{1mm} \textbf{-> -2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LN(X)]{Retourne le logarithme naturel de X (népérien). C'est un synonyme de la fonction LOG(X).}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LN(2) ;} \\
\hspace{1mm} \textbf{-> 0.693147} \\
\hspace{1mm} \textbf{mysql> SELECT LN(-2) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOG(X), LOG(B,X)]{Appelée avec un seul paramètre, cette fonction retourne le logarithme naturel (népérien) de X. Appelée avec deux paramètres, cette fonction retourne le logarithme naturel de X pour une base B arbitraire}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LOG(2) ;} \\
\hspace{1mm} \textbf{-> 0.693147} \\
\hspace{1mm} \textbf{mysql> SELECT LOG(-2) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
\hspace{1mm} \textbf{mysql> SELECT LOG(2,65536) ;} \\
\hspace{1mm} \textbf{-> 16.000000} \\
\hspace{1mm} \textbf{mysql> SELECT LOG(1,100) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOG(B,X)]{est l'équivalent de LOG(X)/LOG(B).}
\item[\hspace{1mm} LOG2(X)]{Retourne le logarithme en base 2 de X. Utile pour trouver combien de bits sont nécessaires pour stocker un nombre}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LOG2(65536) ;} \\
\hspace{1mm} \textbf{-> 16.000000} \\
\hspace{1mm} \textbf{mysql> SELECT LOG2(-100) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MOD(N,M), N \% M, N MOD M Modulo]{(équivalent de l'opérateur \% dans le langage C). Retourne le reste de la division de N par M. Cette fonction ne pose pas de problèmes avec les BIGINT}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MOD(234, 10) ;} \\
\hspace{1mm} \textbf{-> 4} \\
\hspace{1mm} \textbf{mysql> SELECT 253 \% 7 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT MOD(29,9) ;} \\
\hspace{1mm} \textbf{-> 2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} PI()]{Retourne la valeur de pi. Par défaut, 5 décimales sont retournées, mais MySQL utilise la double précision pour pi.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT PI() ;} \\
\hspace{1mm} \textbf{-> 3.141593} \\
\hspace{1mm} \textbf{mysql> SELECT PI()+0.000000000000000000 ;} \\
\hspace{1mm} \textbf{-> 3.141592653589793116} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} POW(X,Y), POWER(X,Y)]{Retourne la valeur de X élevée à la puissance Y}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT POW(2,2) ;} \\
\hspace{1mm} \textbf{-> 4.000000} \\
\hspace{1mm} \textbf{mysql> SELECT POW(2,-2) ;} \\
\hspace{1mm} \textbf{-> 0.250000} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} RADIANS(X)]{Retourne l'argument X, converti de degrés en radians.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT RADIANS(90) ;} \\
\hspace{1mm} \textbf{-> 1.570796} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} RAND(), RAND(N)]{Retourne un nombre aléatoire à virgule flottante compris dans l'intervalle 0 - 1.0. Si l'argument entier N est spécifié, il est utilisé comme initialisation du générateur de nombres aléatoires. Vous ne pouvez pas utiliser une colonne de valeur RAND() dans une clause ORDER BY, parce que ORDER BY va évaluer la colonne plusieurs fois.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT RAND() ;} \\
\hspace{1mm} \textbf{-> 0.9233482386203} \\
\hspace{1mm} \textbf{mysql> SELECT RAND(20) ;} \\
\hspace{1mm} \textbf{-> 0.15888261251047} \\
\hspace{1mm} \textbf{mysql> SELECT RAND(20) ;} \\
\hspace{1mm} \textbf{-> 0.15888261251047} \\
\hspace{1mm} \textbf{mysql> SELECT RAND() ;} \\
\hspace{1mm} \textbf{-> 0.63553050033332} \\
\hspace{1mm} \textbf{mysql> SELECT RAND() ;} \\
\hspace{1mm} \textbf{-> 0.70100469486881} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ROUND(X), ROUND(X,D)]{Retourne l'argument X, arrondi à un nombre à D décimales. Avec deux arguments, la valeur est arrondie avec D décimales. Si D vaut 0, le résultat n'aura ni de partie décimale, ni de séparateur de décimal. Notez que le comportement de l'opérateur \textbf{ROUND()}, lorsque l'argument est exactement entre deux entiers, dépend de la bibliothèque C active. Certaines arrondissent toujours à l'entier pair le plus proche, toujours vers le haut, toujours vers le bas, ou toujours vers zéro. Si vous avez besoin d'un certain type d'arrondissement, vous devez utiliser une fonction bien définie comme \textbf{TRUNCATE()} ou \textbf{FLOOR()}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ROUND(-1.23) ;} \\
\hspace{1mm} \textbf{-> -1} \\
\hspace{1mm} \textbf{mysql> SELECT ROUND(-1.58) ;} \\
\hspace{1mm} \textbf{-> -2} \\
\hspace{1mm} \textbf{mysql> SELECT ROUND(1.58) ;} \\
\hspace{1mm} \textbf{-> 2} \\
\hspace{1mm} \textbf{mysql> SELECT ROUND(1.298, 1) ;} \\
\hspace{1mm} \textbf{-> 1.3} \\
\hspace{1mm} \textbf{mysql> SELECT ROUND(1.298, 0) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT ROUND(23.298, -1) ;} \\
\hspace{1mm} \textbf{-> 20} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SIGN(X)]{Retourne le signe de l'argument sous la forme -1, 0, ou 1, selon que X est négatif, zéro, ou positif.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SIGN(-32) ;} \\
\hspace{1mm} \textbf{-> -1} \\
\hspace{1mm} \textbf{mysql> SELECT SIGN(0) ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT SIGN(234) ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SIN(X)]{Retourne le sinus de X, où X est donné en radians.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SIN(PI()) ;} \\
\hspace{1mm} \textbf{-> 0.000000} \\
\hspace{1mm} \textbf{SQRT(X) Retourne la racine carrée de X.} \\
\hspace{1mm} \textbf{mysql> SELECT SQRT(4) ;} \\
\hspace{1mm} \textbf{-> 2.000000} \\
\hspace{1mm} \textbf{mysql> SELECT SQRT(20) ;} \\
\hspace{1mm} \textbf{-> 4.472136} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TAN(X)]{Retourne la tangente de X, où X est donné en radians.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TAN(PI()+1) ;} \\
\hspace{1mm} \textbf{-> 1.557408} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TRUNCATE(X,D)]{Retourne l'argument X, tronqué à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale. Notez que les nombres décimaux ne sont pas stockés exactement comme les nombres entiers , mais comme des valeurs doubles. Vous pouvez être dupés par le résultat suivant (Ce résultat est normal car 10.28 est actuellement stocké comme cela 10.2799999999999999):}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TRUNCATE(10.28*100,0) ;} \\
\hspace{1mm} \textbf{-> 1027} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Dates et heures }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} ADDDATE(date,INTERVAL expr type), ADDDATE(expr,days)]{Lorsque utilisé avec la forme \textbf{INTERVAL}, \textbf{ADDDATE()} est un synonyme de \textbf{DATE\_ADD()}. La fonction complémentaire \textbf{SUBDATE()} est un synonyme \textbf{DATE\_SUB()}. La seconde syntaxe est utilisée si expr est une expression de type DATE ou DATETIME, et que days est un nombre de jour à ajouter à expr.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1998-01-02', INTERVAL 31 DAY) ;} \\
\hspace{1mm} \textbf{-> '1998-02-02'} \\
\hspace{1mm} \textbf{mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY) ;} \\
\hspace{1mm} \textbf{-> '1998-02-02'} \\
\hspace{1mm} \textbf{mysql> SELECT ADDDATE('1998-01-02', 31) ;} \\
\hspace{1mm} \textbf{-> '1998-02-02'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ADDTIME(expr,expr2) ADDTIME()]{Ajoute \textbf{expr2} à \textbf{expr} et retourne le résultat. \textbf{expr} est une expression de type \textbf{DATE} ou \textbf{DATETIME}, et \textbf{expr2} est une expression de type \textbf{TIME}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ADDTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002") ;} \\
\hspace{1mm} \textbf{-> '1998-01-02 01:01:01.000001'} \\
\hspace{1mm} \textbf{mysql> SELECT ADDTIME("01:00:00.999999", "02:00:00.999998") ;} \\
\hspace{1mm} \textbf{-> '03:00:01.999997'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CURDATE(), CURRENT\_DATE]{Retourne la date courante au format \textbf{'YYYY-MM-DD'} ou \textbf{YYYYMMDD}, suivant le contexte numérique ou chaîne:}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CURDATE() ;} \\
\hspace{1mm} \textbf{-> '1997-12-15'} \\
\hspace{1mm} \textbf{mysql> SELECT CURDATE() + 0 ;} \\
\hspace{1mm} \textbf{-> 19971215} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CURRENT\_DATE, CURRENT\_DATE()]{sont synonymes de \textbf{CURDATE()}.}
\item[\hspace{1mm} CURTIME()]{Retourne l'heure courante au format \textbf{'HH:MM:SS'} or \textbf{HHMMSS} suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CURTIME() ;} \\
\hspace{1mm} \textbf{-> '23:50:26'} \\
\hspace{1mm} \textbf{mysql> SELECT CURTIME() + 0 ;} \\
\hspace{1mm} \textbf{-> 235026} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CURRENT\_TIME, CURRENT\_TIME()]{sont synonymes de \textbf{CURTIME()}}
\item[\hspace{1mm} CURRENT\_TIMESTAMP, CURRENT\_TIMESTAMP()]{sont synonymes de \textbf{NOW()}.}
\item[\hspace{1mm} DATE(expr)]{Extrait la partie date de l'expression \textbf{expr} de type \textbf{DATE} ou \textbf{DATETIME}}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATE('2003-12-31 01:02:03') ;} \\
\hspace{1mm} \textbf{-> '2003-12-31'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DATEDIFF(expr,expr2)]{Retourne le nombre de jours entre la date de début \textbf{expr} et la date de fin \textbf{expr2}. \textbf{expr} et \textbf{expr2} sont des expressions de type \textbf{DATE} ou \textbf{DATETIME}. Seule la partie \textbf{DATE} est utilisée dans le calcul}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30') ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT DATEDIFF('1997-11-31 23:59:59','1997-12-31') ;} \\
\hspace{1mm} \textbf{-> -30} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DATE\_ADD(date,INTERVAL expr type), DATE\_SUB(date,INTERVAL expr type)]{Ces fonctions effectuent des calculs arithmétiques sur les dates. La table suivante indique la signification des arguments \textbf{type} et \textbf{expr}:}
\end{description}
 
{\ttfamily
type Valeur\_\_\_\_\_\_\_\_\_\_\_Attendue expr Format\\ MICROSECOND\_\_\_\_\_\_\_\_\_\_\_MICROSECONDS\\ SECOND\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_SECONDS\\ MINUTE\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_MINUTES\\ HOUR\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_HOURS\\ DAY\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_DAYS\\ WEEK\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_WEEKS\\ MONTH \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_MONTHS\\ QUARTER \_\_\_\_\_\_\_\_\_\_\_\_\_\_QUARTERS\\ YEAR\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_YEARS\\ SECOND\_MICROSECOND\_\_\_\_'SECONDS.MICROSECONDS'\\ MINUTE\_MICROSECOND\_\_\_\_'MINUTES.MICROSECONDS'\\ MINUTE\_SECOND\_\_\_\_\_\_\_\_\_'MINUTES:SECONDS'\\ HOUR\_MICROSECOND\_\_\_\_\_\_'HOURS.MICROSECONDS'\\ HOUR\_SECOND\_\_\_\_\_\_\_\_\_\_\_'HOURS:MINUTES:SECONDS'\\ HOUR\_MINUTE\_\_\_\_\_\_\_\_\_\_\_'HOURS:MINUTES'\\ DAY\_MICROSECOND\_\_\_\_\_\_\_'DAYS.MICROSECONDS'\\ DAY\_SECOND\_\_\_\_\_\_\_\_\_\_\_\_'DAYS HOURS:MINUTES:SECONDS'\\ DAY\_MINUTE\_\_\_\_\_\_\_\_\_\_\_\_'DAYS HOURS:MINUTES'\\ DAY\_HOUR\_\_\_\_\_\_\_\_\_\_\_\_\_\_'DAYS HOURS'\\ YEAR\_MONTH \_\_\_\_\_\_\_\_\_\_\_'YEARS-MONTHS'\\
}
\vspace{8mm}
 
\hspace{1mm}  \textbf{MySQL} autorise tous les signes de ponctuation, comme délimiteur dans le format de \textbf{expr}. Ceux qui sont affichés dans la table sont des suggestions. Si l'argument \textbf{date} est une valeur \textbf{DATE} et que vos calculs impliquent des parties \textbf{YEAR}, \textbf{MONTH} et \textbf{DAY} (c'est à dire, sans partie horaire), le résultat sera de type \textbf{DATE}. Sinon, le résultat est de type \textbf{DATETIME}
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND ;} \\
\hspace{1mm} \textbf{-> '1998-01-01 00:00:00'} \\
\hspace{1mm} \textbf{mysql> SELECT INTERVAL 1 DAY + '1997-12-31' ;} \\
\hspace{1mm} \textbf{-> '1998-01-01'} \\
\hspace{1mm} \textbf{mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND ;} \\
\hspace{1mm} \textbf{-> '1997-12-31 23:59:59'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1997-12-31 23:59:59',} \\
\hspace{1mm} \textbf{-> INTERVAL 1 SECOND) ;} \\
\hspace{1mm} \textbf{-> '1998-01-01 00:00:00'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1997-12-31 23:59:59',} \\
\hspace{1mm} \textbf{-> INTERVAL 1 DAY) ;} \\
\hspace{1mm} \textbf{-> '1998-01-01 23:59:59'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1997-12-31 23:59:59',} \\
\hspace{1mm} \textbf{-> INTERVAL '1:1' MINUTE\_SECOND) ;} \\
\hspace{1mm} \textbf{-> '1998-01-01 00:01:00'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_SUB('1998-01-01 00:00:00',} \\
\hspace{1mm} \textbf{-> INTERVAL '1 1:1:1' DAY\_SECOND) ;} \\
\hspace{1mm} \textbf{-> '1997-12-30 22:58:59'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1998-01-01 00:00:00',} \\
\hspace{1mm} \textbf{-> INTERVAL '-1 10' DAY\_HOUR) ;} \\
\hspace{1mm} \textbf{-> '1997-12-30 14:00:00'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_SUB('1998-01-02', INTERVAL 31 DAY) ;} \\
\hspace{1mm} \textbf{-> '1997-12-02'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1992-12-31 23:59:59.000002',} \\
\hspace{1mm} \textbf{-> INTERVAL '1.999999' SECOND\_MICROSECOND) ;} \\
\hspace{1mm} \textbf{-> '1993-01-01 00:00:01.000001'} \\
 
\hspace{1mm}  Si vous spécifiez un intervalle qui est trop court (il n'inclut pas toutes les parties d'intervalle attendues par type), \textbf{MySQL} suppose que vous avez omis les valeurs de gauche. Par exemple, si vous spécifiez un type type de \textbf{DAY\_SECOND}, la valeur \textbf{expr} devrait contenir des jours, heures, minutes et secondes. Si vous fournissez une valeur de la forme \textbf{'1:10'}, MySQL suppose que les jours et heures manquent, et que la valeur représente des minutes et secondes. En d'autres termes, \textbf{'1:10' DAY\_SECOND} est interprété comme \textbf{'1:10' MINUTE\_SECOND}. C'est similaire au comportement de MySQL avec les valeurs de type TIME, qui représente des durées plutôt que des horaires. Notez que si vous ajoutez ou soustrayez à une valeur de type DATE des horaires, le résultat sera automatiquement au format DATETIME
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1999-01-01', INTERVAL 1 DAY) ;} \\
\hspace{1mm} \textbf{-> '1999-01-02'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1999-01-01', INTERVAL 1 HOUR) ;} \\
\hspace{1mm} \textbf{-> '1999-01-01 01:00:00'} \\
 
\hspace{1mm}  Si vous utilisez des dates malformées, le résultat sera \textbf{NULL}. Si vous ajoutez des \textbf{MONTH}, \textbf{YEAR\_MONTH} ou \textbf{YEAR}, et que le résultat a un jour du mois qui est au-delà de ce qui est possible dans le mois, le jour sera adapté au plus grand jour possible du mois. Par exemple
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT DATE\_ADD('1998-01-30', interval 1 month) ;} \\
\hspace{1mm} \textbf{-> '1998-02-28'} \\
 
\hspace{1mm}  Notez que dans l'exemple précédent, le mot clé \textbf{INTERVAL} et le spécificateur type sont insensibles à la casse.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{DATE\_FORMAT(date,format)}
\item[\hspace{1mm} Formate la date avec le format. Les spécificateurs suivants peuvent être utilisé dans la chaîne format]{}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} \%\%]{Un signe pourcentage littéral ‘\%’.}
\item[\hspace{1mm} \%a]{Nom du jour de la semaine, en abrégé et en anglais (Sun..Sat)}
\item[\hspace{1mm} \%b]{Nom du mois, en abrégé et en anglais (Jan..Dec)}
\item[\hspace{1mm} \%c]{Mois, au format numérique (1..12)}
\item[\hspace{1mm} \%d]{Jour du mois, au format numérique (00..31)}
\item[\hspace{1mm} \%D]{Jour du mois, avec un suffixe anglais (1st, 2nd, 3rd, etc.)}
\item[\hspace{1mm} \%e]{Jour du mois, au format numérique (0..31)}
\item[\hspace{1mm} \%f]{Microsecondes (000000..999999)}
\item[\hspace{1mm} \%H]{Heure (00..23)}
\item[\hspace{1mm} \%h]{Heure (01..12)}
\item[\hspace{1mm} \%I]{Heure (01..12)}
\item[\hspace{1mm} \%i]{Minutes, au format numérique (00..59)}
\item[\hspace{1mm} \%j]{Jour de l'année (001..366)}
\item[\hspace{1mm} \%k]{Heure (0..23)}
\item[\hspace{1mm} \%l]{Heure (1..12)}
\item[\hspace{1mm} \%m]{Mois, au format numérique (01..12)}
\item[\hspace{1mm} \%M]{Nom du mois (January..December)}
\item[\hspace{1mm} \%p]{AM ou PM}
\item[\hspace{1mm} \%r]{Heures, au format 12 heures (hh:mm:ss [AP]M)}
\item[\hspace{1mm} \%s]{Secondes (00..59)}
\item[\hspace{1mm} \%s]{Secondes (00..59)}
\item[\hspace{1mm} \%T]{Heures, au format 24 heures (hh:mm:ss)}
\item[\hspace{1mm} \%U]{Numéro de la semaine (00..53), où Dimanche est le premier jour de la semaine}
\item[\hspace{1mm} \%u]{Numéro de la semaine (00..53), où Lundi est le premier jour de la semaine}
\item[\hspace{1mm} \%V]{Numéro de la semaine (01..53), où Dimanche est le premier jour de la semaine, utilisé avec '\%X'}
\item[\hspace{1mm} \%v]{Numéro de la semaine (01..53), où Lundi est le premier jour de la semaine, utilisé avec '\%x'}
\item[\hspace{1mm} \%W]{Nom du jour de la semaine (Sunday..Saturday)}
\item[\hspace{1mm} \%w]{Numéro du jour de la semaine (0=Sunday..6=Saturday)}
\item[\hspace{1mm} \%X]{Année, pour les semaines qui commencent le Dimanche, au format numérique, sur 4 chiffres, utilisé avec '\%V'}
\item[\hspace{1mm} \%x]{Année, pour les semaines qui commencent le Lundi, au format numérique, sur 4 chiffres, utilisé avec '\%v'}
\item[\hspace{1mm} \%y]{Année, au format numérique, sur 2 chiffres}
\item[\hspace{1mm} \%Y]{Année, au format numérique, sur 4 chiffres}
\end{description}
 
\hspace{1mm} Tous les autres caractères sont simplement copiés dans le résultat sans interprétation \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('1997-10-04 22:23:00', '\%W \%M \%Y') ;} \\
\hspace{1mm} \textbf{-> 'Saturday October 1997'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('1997-10-04 22:23:00', '\%H :\%i :\%s') ;} \\
\hspace{1mm} \textbf{-> '22:23:00'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('1997-10-04 22:23:00',} \\
\hspace{1mm} \textbf{'\%D \%y \%a \%d \%m \%b \%j') ;} \\
\hspace{1mm} \textbf{-> '4th 97 Sat 04 10 Oct 277'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('1997-10-04 22:23:00',} \\
\hspace{1mm} \textbf{'\%H \%k \%I \%r \%T \%S \%w') ;} \\
\hspace{1mm} \textbf{-> '22 22 10 10:23:00 PM 22:23:00 00 6'} \\
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('1999-01-01', '\%X \%V') ;} \\
\hspace{1mm} \textbf{-> '1998 52'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DAY(date) DAY()]{est un synonyme de \textbf{DAYOFMONTH()}.}
\item[\hspace{1mm} DAYNAME(date)]{Retourne le nom du jour de la semaine de date}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DAYNAME('1998-02-05') ;} \\
\hspace{1mm} \textbf{-> 'Thursday'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DAYOFMONTH(date)]{Retourne le jour de la date date, dans un intervalle de 1 à 31}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DAYOFMONTH('1998-02-03') ;} \\
\hspace{1mm} \textbf{-> 3} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DAYOFWEEK(date)]{Retourne l'index du jour de la semaine: pour date (1 = Dimanche, 2 = Lundi, ... 7 = Samedi). Ces index correspondent au standard ODBC}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DAYOFWEEK('1998-02-03') ;} \\
\hspace{1mm} \textbf{-> 3} \\
\hspace{1mm} \textbf{DAYOFYEAR(date) Retourne le jour de la date date, dans un intervalle de 1 à 366 :} \\
\hspace{1mm} \textbf{mysql> SELECT DAYOFYEAR('1998-02-03') ;} \\
\hspace{1mm} \textbf{-> 34} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} EXTRACT(type FROM date)]{La fonction \textbf{EXTRACT()} utilise les mêmes types d'intervalles que la fonction \textbf{DATE\_ADD()} ou la fonction \textbf{DATE\_SUB()}, mais extrait des parties de date plutôt que des opérations de date.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT EXTRACT(YEAR FROM "1999-07-02") ;} \\
\hspace{1mm} \textbf{-> 1999} \\
\hspace{1mm} \textbf{mysql> SELECT EXTRACT(YEAR\_MONTH FROM "1999-07-02 01:02:03") ;} \\
\hspace{1mm} \textbf{-> 199907} \\
\hspace{1mm} \textbf{mysql> SELECT EXTRACT(DAY\_MINUTE FROM "1999-07-02 01:02:03") ;} \\
\hspace{1mm} \textbf{-> 20102} \\
\hspace{1mm} \textbf{mysql> SELECT EXTRACT(MICROSECOND FROM "2003-01-02 10:30:00.00123") ;} \\
\hspace{1mm} \textbf{-> 123} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FROM\_DAYS(N)]{Retourne la date correspondant au nombre de jours (N) depuis la date 0. \textbf{FROM\_DAYS()} n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier Grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FROM\_DAYS(729669) ;} \\
\hspace{1mm} \textbf{-> '1997-10-07'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FROM\_UNIXTIME(unix\_timestamp)]{Retourne une représentation de l'argument unix\_timestamp sous la forme '\textbf{YYYY-MM-DD HH:MM:SS}' ou \textbf{YYYYMMDDHHMMSS}, suivant si la fonction est utilisé dans un contexte numérique ou de chaîne.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FROM\_UNIXTIME(875996580) ;} \\
\hspace{1mm} \textbf{-> '1997-10-04 22:23:00'} \\
\hspace{1mm} \textbf{mysql> SELECT FROM\_UNIXTIME(875996580) + 0 ;} \\
\hspace{1mm} \textbf{-> 19971004222300} \\
 
\hspace{1mm}  Si format est donné, le résultat est formaté en fonction de la chaîne format. format peut contenir les mêmes options de format que celles utilisées par \textbf{DATE\_FORMAT()}
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT FROM\_UNIXTIME(UNIX\_TIMESTAMP(),} \\
\hspace{1mm} \textbf{-> '\%Y \%D \%M \%h :\%i :\%s \%x') ;} \\
\hspace{1mm} \textbf{-> '2003 6th August 06:22:58 2003'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} GET\_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL')]{Retourne une chaîne de format. Cette fonction est pratique lorsqu'elle est utilisée avec les fonctions \textbf{DATE\_FORMAT()} et \textbf{STR\_TO\_DATE()}. Les trois valeurs possibles pour le premier argument, et les cinq valeurs possible pour le second argument donnent 15 formats d'affichage (pour les options utilisées, voyez la table de la fonction \textbf{DATE\_FORMAT())}}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} Appel fonction / Résultat]{}
\item[\hspace{1mm} GET\_FORMAT(DATE,'USA')]{'\%m.\%d.\%Y'}
\item[\hspace{1mm} GET\_FORMAT(DATE,'JIS')]{'\%Y-\%m-\%d'}
\item[\hspace{1mm} GET\_FORMAT(DATE,'ISO')]{'\%Y-\%m-\%d'}
\item[\hspace{1mm} GET\_FORMAT(DATE,'EUR')]{'\%d.\%m.\%Y'}
\item[\hspace{1mm} GET\_FORMAT(DATE,'INTERNAL')]{'\%Y\%m\%d'}
\item[\hspace{1mm} GET\_FORMAT(TIMESTAMP,'USA')]{'\%Y-\%m-\%d-\%H.\%i.\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIMESTAMP,'JIS')]{'\%Y-\%m-\%d \%H :\%i :\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIMESTAMP,'ISO')]{'\%Y-\%m-\%d \%H :\%i :\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIMESTAMP,'EUR')]{'\%Y-\%m-\%d-\%H.\%i.\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIMESTAMP,'INTERNAL')]{'\%Y\%m\%d\%H\%i\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIME,'USA')]{'\%h :\%i :\%s \%p'}
\item[\hspace{1mm} GET\_FORMAT(TIME,'JIS')]{'\%H :\%i :\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIME,'ISO')]{'\%H :\%i :\%s'}
\item[\hspace{1mm} GET\_FORMAT(TIME,'EUR')]{'\%H.\%i.\%S'}
\item[\hspace{1mm} GET\_FORMAT(TIME,'INTERNAL')]{'\%H\%i\%s'}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATE\_FORMAT('2003-10-03', GET\_FORMAT(DATE, 'EUR')} \\
\hspace{1mm} \textbf{-> '03.10.2003'} \\
\hspace{1mm} \textbf{mysql> SELECT STR\_TO\_DATE('10.31.2003', GET\_FORMAT(DATE, 'USA'))} \\
\hspace{1mm} \textbf{-> 2003-10-31} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} HOUR(time)]{Retourne le nombre d'heures pour l'heure time, dans un intervalle de 0 à 23}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT HOUR('10:05:03') ;} \\
\hspace{1mm} \textbf{-> 10} \\
 
\hspace{1mm}  Cependant, l'intervalle des valeurs \textbf{TIME} est bien plus grand, et donc, \textbf{HOUR} peut retourner des valeurs plus grandes que 23
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT HOUR('272:59:59') ;} \\
\hspace{1mm} \textbf{-> 272} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LAST\_DAY(date)]{Prend une valeur de format \textbf{DATE} ou \textbf{DATETIME}, et retourne le dernier jour du mois correspondant. Retourne NULL si l'argument est invalide.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LAST\_DAY('2003-02-05'), LAST\_DAY('2004-02-05') ;} \\
\hspace{1mm} \textbf{-> '2003-02-28', '2004-02-29'} \\
\hspace{1mm} \textbf{mysql> SELECT LAST\_DAY('2004-01-01 01:01:01') ;} \\
\hspace{1mm} \textbf{-> '2004-01-31'} \\
\hspace{1mm} \textbf{mysql> SELECT LAST\_DAY('2003-03-32') ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} LOCALTIME, LOCALTIME()]{sont synonymes de \textbf{NOW()}.}
\item[\hspace{1mm} LOCALTIMESTAMP, LOCALTIMESTAMP()]{sont synonymes de \textbf{NOW()}.}
\item[\hspace{1mm} MAKEDATE(year,dayofyear)]{Retourne une valeur de format \textbf{DATE}, à partir d'une année et du numéro de jour. dayofyear doit être plus grand que 0 ou le résultat sera NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32) ;} \\
\hspace{1mm} \textbf{-> '2001-01-31', '2001-02-01'} \\
\hspace{1mm} \textbf{mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365) ;} \\
\hspace{1mm} \textbf{-> '2001-12-31', '2004-12-30'} \\
\hspace{1mm} \textbf{mysql> SELECT MAKEDATE(2001,0) ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MAKETIME(hour,minute,second)]{Retourne une valeur de format \textbf{TIME}, calculée à partir des arguments hour, minute et second.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MAKETIME(12,15,30) ;} \\
\hspace{1mm} \textbf{-> '12:15:30'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MICROSECOND(expr)]{Retourne le nombre de microsecondes dans l'expression de type \textbf{TIME} ou \textbf{DATETIME expr}, sous la forme d'un nombre entre 0 et 999999.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MICROSECOND('12:00:00.123456') ;} \\
\hspace{1mm} \textbf{-> 123456} \\
\hspace{1mm} \textbf{mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010') ;} \\
\hspace{1mm} \textbf{-> 10} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MINUTE(time)]{Retourne le nombre de minutes pour l'heure time, dans un intervalle de 0 à 59}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MINUTE('98-02-03 10:05:03') ;} \\
\hspace{1mm} \textbf{-> 5} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MONTH(date)]{Retourne le numéro du mois de la date date, dans un intervalle de 1 à 12}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MONTH('1998-02-03') ;} \\
\hspace{1mm} \textbf{-> 2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} MONTHNAME(date)]{Retourne le nom du mois de la date}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MONTHNAME("1998-02-05") ;} \\
\hspace{1mm} \textbf{-> 'February'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} NOW()]{Retourne la date courante au format \textbf{'YYYY-MM-DD HH:MM:SS'} ou \textbf{YYYYMMDDHHMMSS}, suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT NOW() ;} \\
\hspace{1mm} \textbf{-> '1997-12-15 23:50:26'} \\
\hspace{1mm} \textbf{mysql> SELECT NOW() + 0 ;} \\
\hspace{1mm} \textbf{-> 19971215235026} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} PERIOD\_ADD(P,N)]{Ajoute N mois à la période P (au format YYMM ou YYYYMM). Retourne une valeur dans le format YYYYMM. Notez que l'argument P n'est pas de type date}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT PERIOD\_ADD(9801,2) ;} \\
\hspace{1mm} \textbf{-> 199803} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} PERIOD\_DIFF(P1,P2)]{Retourne le nombre de mois entre les périodes P1 et P2. P1 et P2 doivent être au format YYMM ou YYYYMM. Notez que les arguments P1 et P2 ne sont pas de type date}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT PERIOD\_DIFF(9802,199703) ;} \\
\hspace{1mm} \textbf{-> 11} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} QUARTER(date)]{Retourne le numéro du trimestre de la date date, dans un intervalle de 1 à 4}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT QUARTER('98-04-01') ;} \\
\hspace{1mm} \textbf{-> 2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SECOND(time)]{Retourne le nombre de secondes pour l'heure time, dans un intervalle de 0 à 59}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SECOND('10:05:03') ;} \\
\hspace{1mm} \textbf{-> 3} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SEC\_TO\_TIME(seconds)]{Retourne l'argument seconds, convertit en heures, minutes et secondes au format \textbf{'HH:MM:SS'} ou \textbf{HHMMSS}, suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SEC\_TO\_TIME(2378) ;} \\
\hspace{1mm} \textbf{-> '00:39:38'} \\
\hspace{1mm} \textbf{mysql> SELECT SEC\_TO\_TIME(2378) + 0 ;} \\
\hspace{1mm} \textbf{-> 3938} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} STR\_TO\_DATE(str,format)]{Cette fonction est l'inverse de la fonction \textbf{DATE\_FORMAT()}. Elle prend la chaîne str, et une chaîne de format format, puis retourne une valeur \textbf{DATETIME}. Les valeurs de type \textbf{DATE}, \textbf{TIME} ou \textbf{DATETIME} contenues dans la chaîne str doivent être au format spécifié. Pour les options qui sont utilisables dans la chaîne format, voyez la table dans la description de la fonction \textbf{DATE\_FORMAT()}. Tous les autres caractères sont utilisés littéralement, et ne seront pas interprétés. Si str contient une valeur illégale, \textbf{STR\_TO\_DATE()} retourne NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT STR\_TO\_DATE('03.10.2003 09.20', '\%d.\%m.\%Y \%H.\%i')} \\
\hspace{1mm} \textbf{-> 2003-10-03 09:20:00} \\
\hspace{1mm} \textbf{mysql> SELECT STR\_TO\_DATE('10rap', '\%crap')} \\
\hspace{1mm} \textbf{-> 0000-10-00 00:00:00} \\
\hspace{1mm} \textbf{mysql> SELECT STR\_TO\_DATE('2003-15-10 00:00:00', '\%Y-\%m-\%d \%H :\%i :\%s')} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days)]{Lorsqu'elle est utilisée avec la forme \textbf{INTERVAL} du second argument, \textbf{SUBDATE()} est synonyme \textbf{DATE\_SUB()}}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATE\_SUB('1998-01-02', INTERVAL 31 DAY) ;} \\
\hspace{1mm} \textbf{-> '1997-12-02'} \\
\hspace{1mm} \textbf{mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY) ;} \\
\hspace{1mm} \textbf{-> '1997-12-02'} \\
\hspace{1mm} \textbf{mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31) ;} \\
\hspace{1mm} \textbf{-> '1997-12-02 12:00:00'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SUBTIME(expr,expr2) SUBTIME()]{Soustrait \textbf{expr2} de \textbf{expr} et retourne le résultat. expr est une expression de format \textbf{DATE} ou \textbf{DATETIME} et \textbf{expr2} est une expression de type \textbf{TIME}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SUBTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002") ;} \\
\hspace{1mm} \textbf{-> '1997-12-30 22:58:58.999997'} \\
\hspace{1mm} \textbf{mysql> SELECT SUBTIME("01:00:00.999999", "02:00:00.999998") ;} \\
\hspace{1mm} \textbf{-> '-00:59:59.999999'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SYSDATE()]{est un synonyme de NOW().}
\item[\hspace{1mm} TIME(expr)]{Extrait la partie horaire de l'expression expr, de type \textbf{TIME} ou \textbf{DATETIME}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIME('2003-12-31 01:02:03') ;} \\
\hspace{1mm} \textbf{-> '01:02:03'} \\
\hspace{1mm} \textbf{mysql> SELECT TIME('2003-12-31 01:02:03.000123') ;} \\
\hspace{1mm} \textbf{-> '01:02:03.000123'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIMEDIFF(expr,expr2) TIMEDIFF()]{retourne la durée entre l'heure de début expr et l'heure de fin expr2. expr et expr2 sont des expressions de type TIME ou DATETIME, et doivent être de même type.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIMEDIFF('2000:01:01 00:00:00', '2000:01:01 00:00:00.000001') ;} \\
\hspace{1mm} \textbf{-> '-00:00:00.000001'} \\
\hspace{1mm} \textbf{mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001','1997-12-30 01:01:01.000002') ;} \\
\hspace{1mm} \textbf{-> '46:58:57.999999'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIMESTAMP(expr), TIMESTAMP(expr,expr2)]{Avec un seul argument, retourne l'expression expr de type DATE ou DATETIME sous la forme d'une valeur DATETIME. Avec deux arguments, ajouter l'expression expr2 à l'expression expr et retourne le résultat au format DATETIME.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMP('2003-12-31') ;} \\
\hspace{1mm} \textbf{-> '2003-12-31 00:00:00'} \\
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00') ;} \\
\hspace{1mm} \textbf{-> '2004-01-01 00:00:00'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIMESTAMPADD(interval,int\_expr,datetime\_expr)]{Ajoute l'expression entière \textbf{int\_expr} à l'expression \textbf{datetime\_expr} au format \textbf{DATE} ou \textbf{DATETIME}. L'unité de \textbf{int\_expr} est donnée avec l'argument \textbf{interval}, qui peut être l'une des valeurs suivantes : \textbf{FRAC\_SECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, ou YEAR}. La valeur interval peut être spécifiée, en utilisant un des mots-clé cités, ou avec le préfixe \textbf{SQL\_TSI\_}. Par exemple, \textbf{DAY} et \textbf{SQL\_TSI\_DAY} sont tous les deux valides.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02') ;} \\
\hspace{1mm} \textbf{-> '2003-01-02 00:01:00'} \\
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02') ;} \\
\hspace{1mm} \textbf{-> '2003-01-09'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIMESTAMPDIFF(interval,datetime\_expr1,datetime\_expr2)]{Retourne la différence entière entre les expressions \textbf{datetime\_expr1} et \textbf{datetime\_expr2}, de format \textbf{DATE} et \textbf{DATETIME}. L'unité du résultat est donné par l'argument interval. Les valeurs légales de interval sont les mêmes que pour la fonction \textbf{TIMESTAMPADD()}.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01') ;} \\
\hspace{1mm} \textbf{-> 3} \\
\hspace{1mm} \textbf{mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01') ;} \\
\hspace{1mm} \textbf{-> -1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIME\_FORMAT(time,format)]{Cette fonction est utilisée exactement comme la fonction \textbf{DATE\_FORMAT()} ci-dessus, mais la chaîne format ne doit utiliser que des spécificateurs d'heures, qui gèrent les heures, minutes et secondes. Les autres spécificateurs génèreront la valeur NULL ou 0. Si la valeur time contient une valeur d'heure qui est plus grande que 23, les formats \%H et \%k produiront une valeur qui est hors de l'intervalle 0..23. L'autre format d'heure produira une heure modulo 12}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIME\_FORMAT('100:00:00', '\%H \%k \%h \%I \%l') ;} \\
\hspace{1mm} \textbf{-> '100 100 04 04 4'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TIME\_TO\_SEC(time)]{Retourne l'argument time, convertit en secondes}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TIME\_TO\_SEC('22:23:00') ;} \\
\hspace{1mm} \textbf{-> 80580} \\
\hspace{1mm} \textbf{mysql> SELECT TIME\_TO\_SEC('00:39:38') ;} \\
\hspace{1mm} \textbf{-> 2378} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} TO\_DAYS(date)]{Retourne le nombre de jours depuis la date 0 jusqu'à la date date. \textbf{TO\_DAYS()} n'est pas fait pour travailler avec des dates qui précèdent l'avènement du calendrier Grégorien (1582), car elle ne prend pas en compte les jours perdus lors du changement de calendrier.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT TO\_DAYS(950501) ;} \\
\hspace{1mm} \textbf{-> 728779} \\
\hspace{1mm} \textbf{mysql> SELECT TO\_DAYS('1997-10-07') ;} \\
\hspace{1mm} \textbf{-> 729669} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UNIX\_TIMESTAMP(), UNIX\_TIMESTAMP(date)]{Lorsqu'elle est appelé sans argument, cette fonction retourne un timestamp Unix (nombre de secondes depuis '1970-01-01 00:00:00' GMT). Si \textbf{UNIX\_TIMESTAMP()} est appelé avec un argument date, elle retourne le timestamp correspondant à cette date. date peut être une chaîne de type DATE, DATETIME, TIMESTAMP, ou un nombre au format YYMMDD ou YYYYMMDD, en horaire local. Lorsque \textbf{UNIX\_TIMESTAMP} est utilisé sur une colonne de type TIMESTAMP, la fonction reçoit directement la valeur, sans conversion explicite. Si vous donnez à UNIX\_TIMESTAMP() une date hors de son intervalle de validité, elle retourne 0. Si vous voulez soustraire une colonne de type UNIX\_TIMESTAMP(), vous devez sûrement vouloir un résultat de type entier signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UNIX\_TIMESTAMP() ;} \\
\hspace{1mm} \textbf{-> 882226357} \\
\hspace{1mm} \textbf{mysql> SELECT UNIX\_TIMESTAMP('1997-10-04 22:23:00') ;} \\
\hspace{1mm} \textbf{-> 875996580} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UTC\_DATE, UTC\_DATE()]{Retourne la date \textbf{UTC} courante au format \textbf{'YYYY-MM-DD'} ou \textbf{YYYYMMDD} suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UTC\_DATE(), UTC\_DATE() + 0 ;} \\
\hspace{1mm} \textbf{-> '2003-08-14', 20030814} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UTC\_TIME, UTC\_TIME()]{Retourne l'heure UTC courante au format 'HH:MM:SS' or HHMMSS suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UTC\_TIME(), UTC\_TIME() + 0 ;} \\
\hspace{1mm} \textbf{-> '18:07:53', 180753} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} UTC\_TIMESTAMP, UTC\_TIMESTAMP()]{Retourne l'heure et la date UTC courante au format 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS suivant le contexte numérique ou chaîne}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT UTC\_TIMESTAMP(), UTC\_TIMESTAMP() + 0 ;} \\
\hspace{1mm} \textbf{-> '2003-08-14 18:08:04', 20030814180804} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} WEEK(date \texttt{[},mode\texttt{]})]{Avec un seul argument, retourne le numéro de la semaine dans l'année de la date spécifiée, dans un intervalle de 0 à 53 (oui, il peut y avoir un début de semaine numéro 53), en considérant que Dimanche est le premier jour de la semaine. Avec deux arguments, la fonction WEEK() vous permet de spécifier si les semaines commencent le Dimanche ou le Lundi et la valeur retournée sera dans l'intervalle 0-53 ou bien 1-52. Lorsque l'argument mode est omis, la valeur de la variable default\_week\_format est utilisé. Voici un tableau explicatif sur le fonctionnement du second argument}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} Valeur / Signification]{}
\item[\hspace{1mm} 0]{La semaine commence le Sunday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année}
\item[\hspace{1mm} 1]{La semaine commence le Monday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours}
\item[\hspace{1mm} 2]{La semaine commence le Sunday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année}
\item[\hspace{1mm} 3]{La semaine commence le Monday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours}
\item[\hspace{1mm} 4]{La semaine commence le Sunday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours}
\item[\hspace{1mm} 5]{La semaine commence le Monday ;l'intervalle de valeur de retour va de 0 à !2 ; la semaine 1 est la première semaine de l'année}
\item[\hspace{1mm} 6]{La semaine commence le Sunday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'année qui a plus de trois jours}
\item[\hspace{1mm} 7]{La semaine commence le Monday ;l'intervalle de valeur de retour va de 1 à !2 ; la semaine 1 est la première semaine de l'anné}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT WEEK('1998-02-20') ;} \\
\hspace{1mm} \textbf{-> 7} \\
\hspace{1mm} \textbf{mysql> SELECT WEEK('1998-02-20',0) ;} \\
\hspace{1mm} \textbf{-> 7} \\
\hspace{1mm} \textbf{mysql> SELECT WEEK('1998-02-20',1) ;} \\
\hspace{1mm} \textbf{-> 8} \\
\hspace{1mm} \textbf{mysql> SELECT WEEK('1998-12-31',1) ;} \\
\hspace{1mm} \textbf{-> 53} \\
 
\hspace{1mm}  Si vous préférez que le résultat soit calculé en fonction de l'année qui contient le premier jour de la semaine de la date utilisée en argument, vous devriez utiliser les valeurs 2, 3, 6, or 7 de l'argument mode.
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0) ;} \\
\hspace{1mm} \textbf{-> 2000, 0} \\
\hspace{1mm} \textbf{mysql> SELECT WEEK('2000-01-01',2) ;} \\
\hspace{1mm} \textbf{-> 52} \\
\hspace{1mm} Alternativement, utilisez la fonction YEARWEEK() \\
\hspace{1mm} \textbf{mysql> SELECT YEARWEEK('2000-01-01') ;} \\
\hspace{1mm} \textbf{-> 199952} \\
\hspace{1mm} \textbf{mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2) ;} \\
\hspace{1mm} \textbf{-> '52'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} WEEKDAY(date)]{Retourne l'index du jour de la semaine, avec la conversion suivante : date (0 = Lundi, 1 = Mardi, ... 6 = Dimanche).}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT WEEKDAY('1997-10-04 22:23:00') ;} \\
\hspace{1mm} \textbf{-> 5} \\
\hspace{1mm} \textbf{mysql> SELECT WEEKDAY('1997-11-05') ;} \\
\hspace{1mm} \textbf{-> 2} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} WEEKOFYEAR(date)]{Retourne le numéro de semaine dans l'année, sous forme d'un nombre compris entre 1 et 53.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT WEEKOFYEAR('1998-02-20') ;} \\
\hspace{1mm} \textbf{-> 8} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} YEAR(date)]{Retourne l'année de la date date, dans un intervalle de 1000 à 9999}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT YEAR('98-02-03') ;} \\
\hspace{1mm} \textbf{-> 1998} \\
\hspace{1mm} \textbf{mysql> SELECT YEAR('98-02-03') ;} \\
\hspace{1mm} \textbf{-> 1998} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} YEARWEEK(date), YEARWEEK(date,start)]{Retourne l'année et la semaine d'une date. L'argument start fonctionne exactement comme l'argument start de la fonction WEEK(). Notez que l'année dans le résultat peut être différente de l'année passée en argument, pour la première et la dernière semaine de l'année. Notez que le numéro de semaine est différent de celui que la fonction WEEK() retourne (0) pour les arguments optionnels 0 ou 1, comme WEEK() puis retourne la semaine dans le contexte de l'année.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT YEARWEEK('1987-01-01') ;} \\
\hspace{1mm} \textbf{-> 198653} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions sur les bits }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{MySQL utilise l'arithmétique des \textbf{BIGINT} (64-bits) pour les opérations sur les bits. Ces opérateurs travaillent donc sur 64 bits.}
\item[\hspace{1mm} |]{OU bit-à-bit (OR). Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 29 | 15 ;} \\
\hspace{1mm} \textbf{-> 31} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} \&]{ET bit-à-bit (AND). Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 29 \& 15 ;} \\
\hspace{1mm} \textbf{-> 13} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} \textasciicircum]{XOR bit-à-bit. Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 \textasciicircum  1 ;} \\
\hspace{1mm} \textbf{-> 0} \\
\hspace{1mm} \textbf{mysql> SELECT 1 \textasciicircum  0 ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT 11 \textasciicircum  3 ;} \\
\hspace{1mm} \textbf{-> 8} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} <<]{Décale les bits de l'entier (BIGINT) sur la gauche. Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 1 << 2 ;} \\
\hspace{1mm} \textbf{-> 4} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} >>]{Décale les bits de l'entier (BIGINT) sur la droite. Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 4 >> 2 ;} \\
\hspace{1mm} \textbf{-> 1} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{Inverse tous les bits. Le résultat est un entier de 64 bits non signé.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT 5 \& 1 ;} \\
\hspace{1mm} \textbf{-> 4} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} BIT\_COUNT(N)]{Retourne le nombre de bits non nuls de l'argument N}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT BIT\_COUNT(29) ;} \\
\hspace{1mm} \textbf{-> 4} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions de chiffrement }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} AES\_ENCRYPT(str,key\_str), AES\_DECRYPT(crypt\_str,key\_str)]{Ces fonctions permettent le chiffrement/déchiffrement de données utilisant l'algorithme AES. Une clé de 128 bits est utilisé pour le chiffrement. Les arguments peuvent être de n'importe quelle taille. Si l'un des arguments est NULL, le résultat de cette fonction sera NULL.}
\end{description}
 
\hspace{1mm} Vous pouvez utiliser les fonctions AES pour stocker des données sous une forme chiffrées en modifiant vos requêtes \\
\hspace{1mm} \textbf{INSERT INTO t VALUES (1,AES\_ENCRYPT("text","password")) ;} \\
\hspace{1mm} Vous pouvez obtenir encore plus de sécurité en évitant de transférer la clé pour chaque requête, en la stockant dans une variable sur le serveur au moment de la connexion \\
\hspace{1mm} \textbf{SELECT @password :="my password" ;} \\
\hspace{1mm} \textbf{INSERT INTO t VALUES (1,AES\_ENCRYPT("text",@password)) ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DECODE(crypt\_str,pass\_str)]{Déchiffre la chaîne chiffrée \textbf{crypt\_str} en utilisant la clé \textbf{pass\_str}. \textbf{crypt\_str} doit être une chaîne qui a été renvoyée par la fonction \textbf{ENCODE()}.}
\item[\hspace{1mm} ENCODE(str,pass\_str)]{Chiffre la chaîne \textbf{str} en utilisant la clé \textbf{pass\_str}. Pour déchiffrer le résultat, utilisez la fonction \textbf{DECODE()}. Le résultat est une chaîne binaire de la même longueur que string. Si vous voulez sauvegarder le résultat dans une colonne, utilisez une colonne de type BLOB.}
\item[\hspace{1mm} DES\_DECRYPT(crypt\_str\texttt{[},key\_str\texttt{]})]{Déchiffre une chaîne chiffrée à l'aide de la fonction \textbf{DES\_ENCRYPT()}. Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. Si l'argument \textbf{key\_string} n'est pas donné, la fonction \textbf{DES\_DECRYPT()} examine le premier bit de la chaîne chiffrée pour déterminer le numéro de clé DES utilisé pour chiffrer la chaîne originale, alors la clé est lu dans le fichier \textbf{des-key-file} pour déchiffrer le message. Pour pouvoir utiliser cela, l'utilisateur doit avoir le privilège \textbf{SUPER}. Si vous passé l'argument \textbf{key\_string} à cette fonction, cette chaîne est utilisée comme clé pour déchiffrer le message. Si la chaîne \textbf{string\_to\_decrypt} ne semble pas être une chaîne chiffrée, MySQL retournera la chaîne \textbf{string\_to\_decrypt}. Si une erreur survient, cette fonction retourne NULL.}
\item[\hspace{1mm} DES\_ENCRYPT(str\texttt{[},(key\_num|key\_str)\texttt{]})]{Chiffre la chaîne avec la clé donnée en utilisant l'algorithme DES. Notez que cette fonction fonctionne uniquement si vous avez configuré MySQL avec le support SSL. La clé de hachage utilisée est choisie en suivant les recommandations suivantes}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} Un seul argument]{La première clé de des-key-file est utilisée.}
\item[\hspace{1mm} Un numéro de clé]{Le numéro de la clé donnée (0-9) de des-key-file est utilisée.}
\item[\hspace{1mm} Une chaîne]{La chaîne donnée key\_string doit être utilisé pour chiffrer string\_to\_encrypt.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{La chaîne retournée doit être une chaîne binaire où le premier caractère doit être \textbf{CHAR(128 | key\_number)}.}
\item[\hspace{1mm} ]{Le nombre 128 a été ajouté pour reconnaître facilement une clé de hachage. Si vous utilisez une chaîne comme clé, \textbf{key\_number} doit être 127.}
\item[\hspace{1mm} ]{Si une erreur survient, la fonction retournera NULL.}
\item[\hspace{1mm} ]{La longueur de la chaîne de résultat doit être : \textbf{new\_length= org\_length + (8-(org\_length \% 8))+1.}}
\item[\hspace{1mm} ]{Chaque \textbf{key\_number} doit être un nombre dans l'intervalle 0 à 9. Les lignes dans le fichier peuvent être dans n'importe quel ordre. \textbf{des\_key\_string} est la chaîne qui permettra le chiffrement du message. Entre le nombre et la clé, il doit y avoir au moins un espace. La première clé est la clé par défaut qui sera utilisé si vous ne spécifiez pas d'autres clés en arguments de la fonction \textbf{DES\_ENCRYPT()}.}
\item[\hspace{1mm} ]{Vous pouvez demander à MySQL de lire de nouvelles valeurs de clé dans le fichier de clés avec la commande \textbf{FLUSH DES\_KEY\_FILE}. Cela requière le privilège \textbf{Reload\_priv}.}
\item[\hspace{1mm} ]{Un des bénéfices d'avoir une liste de clés par défaut est que cela donne aux applications la possibilité de regarder l'existence de la valeur chiffrée de la colonne, sans pour autant donner la possibilité à l'utilisateur final de déchiffrer ces valeurs.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT customer\_address FROM customer\_table WHERE} \\
\hspace{1mm} \textbf{crypted\_credit\_card = DES\_ENCRYPT("credit\_card\_number") ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ENCRYPT(str\texttt{[},salt\texttt{]})]{Chiffre la chaîne str en utilisant la fonction crypt(). L'argument salt doit être une chaîne de deux caractères.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT ENCRYPT("hello") ;} \\
\hspace{1mm} \textbf{-> 'VxuFAJXVARROc'} \\
 
\hspace{1mm}  Si la fonction \textbf{crypt()} n'est pas disponible sur votre système, la fonction \textbf{ENCRYPT()} retournera toujours NULL. La fonction \textbf{ENCRYPT()} conserve uniquement les 8 premiers caractères de la chaîne str, au moins, sur certains système. Le comportement exact est directement déterminé par la fonction système crypt() sous-jacente.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} MD5(str)]{Calcul la somme de vérification MD5 de la chaîne string. La valeur retournée est un entier hexadécimal de 32 caractères qui peut être utilisé, par exemple, comme clé de hachage. C'est l'algorithme RSA ("RSA Data Security, Inc. MD5 Message-Digest Algorithm").}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT MD5("testing") ;} \\
\hspace{1mm} \textbf{-> 'ae2b1fca515949e5d54fb22b8ed95575'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} OLD\_PASSWORD(str)]{retourne la valeur pre-4.1 de PASSWORD()}
\item[\hspace{1mm} PASSWORD(str)]{Calcule un mot de passe chiffré à partir de la chaîne str. C'est cette fonction qui est utilisé pour chiffrer les mots de passes MySQL pour être stockés dans une colonne de type Password de la table user. Le chiffrage par PASSWORD() n'est pas réversible. PASSWORD() n'est pas un chiffrage comparable à la fonction de chiffrage Unix. Voir ENCRYPT(). La fonction PASSWORD() est utilisée durant l'identification au serveur MYSQL. Il est recommandé de ne pas l'utiliser pour vos applications. Utilisez plutôt MD5() ou SHA1().}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT PASSWORD('badpwd') ;} \\
\hspace{1mm} \textbf{-> '7f84554057dd964b'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} SHA1(str), SHA(str)]{Calcule la somme de vérification SHA1 160 bits de la chaîne string, comme décrit dans la RFC 3174 (Secure Hash Algorithm). La valeur retournée est un entier hexadécimal de 40 caractères, ou bien NULL dans le cas où l'argument vaut NULL. Une des possibilités d'utilisation de cette fonction est le hachage de clé. Vous pouvez aussi l'utiliser comme fonction de cryptographie sûre pour stocker les mots de passe. La fonction SHA1() a été ajoutée dans la version 4.0.2 de MySQL et peut être considérée comme une méthode de cryptographie plus sûre que la fonction MD5(). La fonction SHA() est un alias de la fonction SHA1()}
\end{description}
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions d'information }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} BENCHMARK(count,expr)]{La fonction \textbf{BENCHMARK()} exécute l'expression expr de manière répétée count fois. Elle permet de tester la vélocité de MySQL lors du traitement d'une requête. Le résultat est toujours 0. L'objectif de cette fonction ne se voit que du côté client, qui permet à ce dernier d'afficher la durée d'exécution de la requête. Le temps affiché est le temps côté client, et non pas les ressources processeurs consommées. il est conseillé d'utiliser \textbf{BENCHMARK()} plusieurs fois de suite pour interpréter un résultat, en dehors de charges ponctuelles sur le serveur.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT BENCHMARK(1000000,ENCODE("bonjour","au revoir")) ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CHARSET(str)]{Retourne le jeu de caractères de la chaîne argument.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CHARSET('abc') ;} \\
\hspace{1mm} \textbf{-> 'latin1'} \\
\hspace{1mm} \textbf{mysql> SELECT CHARSET(CONVERT('abc' USING utf8)) ;} \\
\hspace{1mm} \textbf{-> 'utf8'} \\
\hspace{1mm} \textbf{mysql> SELECT CHARSET(USER()) ;} \\
\hspace{1mm} \textbf{-> 'utf8'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{Les valeurs retournées possibles sont (Les valeurs les plus faibles ont la plus haute priorité):}
\item[\hspace{1mm} 0]{Collation explicite}
\item[\hspace{1mm} 1]{Par de collation}
\item[\hspace{1mm} 2]{Collation implicite}
\item[\hspace{1mm} 3]{Coercible}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} COLLATION(str)]{Retourne la collation du jeu de caractères de la chaîne argument}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COLLATION('abc') ;} \\
\hspace{1mm} \textbf{-> 'latin1\_swedish\_ci'} \\
\hspace{1mm} \textbf{mysql> SELECT COLLATION(\_utf8'abc') ;} \\
\hspace{1mm} \textbf{-> 'utf8\_general\_ci'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CONNECTION\_ID()]{Retourne l'identifiant de connexion courant (thread\_id). Chaque connexion a son propre identifiant unique}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT CONNECTION\_ID() ;} \\
\hspace{1mm} \textbf{-> 23786} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CURRENT\_USER()]{Retourne le nom d'utilisateur et le nom d'hôte de la session courante. Cette valeur correspond au compte qui a été utilisé durant l'identification auprès du serveur. Cela peut être différent des valeurs de USER().}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT USER() ;} \\
\hspace{1mm} \textbf{-> 'davida@localhost'} \\
\hspace{1mm} \textbf{mysql> SELECT * FROM mysql.user ;} \\
\hspace{1mm} \textbf{ERROR 1044 : Access denied for user : '@localhost' to} \\
\hspace{1mm} \textbf{database 'mysql'} \\
\hspace{1mm} \textbf{mysql> SELECT CURRENT\_USER() ;} \\
\hspace{1mm} \textbf{-> '@localhost'} \\
 
\hspace{1mm}  Cet exemple montre que même si le client a indiqué le nom d'utilisateur davida (comme mentionné par la fonction USER()), le serveur a identifié le client comme un utilisateur anonyme (comme indiqué par la fonction CURRENT\_USER()). Une situation qui arrive s'il n'y a aucun compte de listé dans les tables de droits pour davida.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} DATABASE()]{Retourne le nom de la base de données courante. Si aucune base de données n'a été sélectionnée, DATABASE() retourne une chaîne vide. A partir de la version 4.1.1, elle retourne NULL.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT DATABASE() ;} \\
\hspace{1mm} \textbf{-> 'test'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} FOUND\_ROWS()]{Une commande \textbf{SELECT} peut inclure une clause \textbf{LIMIT} pour restreindre le nombre de lignes qui sera retourné par le client. Dans certains cas, il est mieux de savoir combien de lignes une commande aurait retourné, sans la clause \textbf{LIMIT}, mais sans lancer à nouveau le calcul. Pour cela, ajoutez l'option \textbf{SQL\_CALC\_FOUND\_ROWS} dans la commande \textbf{SELECT}, puis appelez \textbf{FOUND\_ROWS()} après.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT SQL\_CALC\_FOUND\_ROWS * FROM tbl\_name} \\
\hspace{1mm} \textbf{-> WHERE id > 100 LIMIT 10 ;} \\
\hspace{1mm} \textbf{mysql> SELECT FOUND\_ROWS() ;} \\
 
\hspace{1mm}  Le second \textbf{SELECT} retourne un nombre indiquant combien de lignes le premier \textbf{SELECT} aurait retourné s'il n'avait pas été écrit avec une clause \textbf{LIMIT}. Notez que si vous utilisez \textbf{SELECT SQL\_CALC\_FOUND\_ROWS ...}, MySQL calcule toutes les lignes dans la liste des résultats. Ainsi, c'est plus rapide si vous n'utilisez pas de clause \textbf{LIMIT} et que la liste des résultats n'a pas besoin d'être envoyée au client. Si la commande \textbf{SELECT} précédente n'inclut pas l'option \textbf{SQL\_CALC\_FOUND\_ROWS}, alors \textbf{FOUND\_ROWS()} pourrait retourner une valeur différente suivant que \textbf{LIMIT} est utilisé ou pas.
\vspace{5mm} \\
 
 
\hspace{1mm}  \textbf{SQL\_CALC\_FOUND\_ROWS} et \textbf{FOUND\_ROWS()} peuvent être pratiques dans des situations où vous devez limiter le nombre de lignes que la requête retourne, mais que vous devez tout de même connaître le nombre de lignes total, sans exécuter une seconde requête. Un exemple classique est un script web qui présente des résultats de recherche. En utilisant \textbf{FOUND\_ROWS()}, vous connaîtrez facilement le nombre de lignes de résultat. L'utilisation de \textbf{SQL\_CALC\_FOUND\_ROWS} et \textbf{FOUND\_ROWS()} est plus complexe pour les requêtes \textbf{UNION} que pour les commandes \textbf{SELECT} simples, car \textbf{LIMIT} peut intervenir plusieurs fois dans une commande UNION. Elle sera appliquée à différentes commandes \textbf{SELECT} de la commande \textbf{UNION}, ou globalement à l'UNION.
\vspace{5mm} \\
 
 
\hspace{1mm}  Le but de \textbf{SQL\_CALC\_FOUND\_ROWS} pour \textbf{UNION} est de retourner le nombre de lignes qui aurait été retourné sans la clause globale \textbf{LIMIT}. Les conditions d'utilisation de \textbf{SQL\_CALC\_FOUND\_ROWS} avec \textbf{UNION} sont
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{6mm} -]{Le mot clé \textbf{SQL\_CALC\_FOUND\_ROWS} doit apparaître dans le premier \textbf{SELECT} de \textbf{l'UNION}.}
\item[\hspace{6mm} -]{La valeur de \textbf{FOUND\_ROWS()} est exactement la même que si \textbf{UNION ALL} était utilisé. Si \textbf{UNION} sans \textbf{ALL} est utilisé, des réductions de doublons surviendront, et la valeur de \textbf{FOUND\_ROWS()} sera approximative.}
\item[\hspace{6mm} -]{Si aucune clause \textbf{LIMIT} n'est présente dans \textbf{UNION}, \textbf{SQL\_CALC\_FOUND\_ROWS} est ignoré et retourne le nombre de lignes dans la table temporaire créé durant le traitement de l'\textbf{UNION}.}
\end{description}
 
\begin{description} \normalsize
\item[\hspace{1mm} LAST\_INSERT\_ID(), LAST\_INSERT\_ID(expr)]{Retourne le dernier identifiant automatiquement généré par une colonne AUTO\_INCREMENT.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT LAST\_INSERT\_ID() ;} \\
\hspace{1mm} \textbf{-> 195} \\
 
\hspace{1mm}  Le dernier \textbf{ID} généré est conservé par le serveur pour chaque connexion. Un autre client ne la modifiera donc pas, même s'ils génèrent une autre valeur \textbf{AUTO\_INCREMENT} de leur coté. Ce comportement permet de s'assurer que les actions des autres clients ne perturbe pas les actions du client en cours. La valeur de \textbf{LAST\_INSERT\_ID()} ne sera pas modifiée non plus si vous modifiez directement la valeur d'une colonne \textbf{AUTO\_INCREMENT} avec une valeur simple (c'est à dire, une valeur qui n'est ni NULL, ni 0).
\vspace{5mm} \\
 
 
\hspace{1mm}  Si vous insérez plusieurs lignes au même moment avec une requête \textbf{INSERT}, \textbf{LAST\_INSERT\_ID()} retourne la valeur de la première ligne insérée. La raison à cela est que cela rend possible la reproduction facilement la même requête \textbf{INSERT} sur d'autres serveurs. Si vous utilisez une commande \textbf{INSERT IGNORE} et que la ligne est ignorée, le compteur \textbf{AUTO\_INCREMENT} sera malgré tout incrémenté, et \textbf{LAST\_INSERT\_ID()} retournera une nouvelle valeur. Si \textbf{expr} est donnée en argument à la fonction \textbf{LAST\_INSERT\_ID()}, alors la valeur de l'argument sera retourné par la fonction et sera enregistré comme étant la prochaine valeur retournée par \textbf{LAST\_INSERT\_ID()}. Cela peut être utilisé pour simuler des séquences.
\vspace{5mm} \\
 
 
\hspace{1mm} Commencez par créer la table suivante \\
\hspace{1mm} \textbf{mysql> CREATE TABLE sequence (id INT NOT NULL) ;} \\
\hspace{1mm} \textbf{mysql> INSERT INTO sequence VALUES (0) ;} \\
\hspace{1mm} Utilisez cette table pour générer des séquences de nombre comme ceci \\
\hspace{1mm} \textbf{mysql> UPDATE sequence SET id=LAST\_INSERT\_ID(id+1) ;} \\
\hspace{1mm} \textbf{mysql> SELECT LAST\_INSERT\_ID() ;} \\
 
\hspace{1mm}  La commande \textbf{UPDATE} incrémente le compteur de séquence, et fait que le prochain appel à \textbf{LAST\_INSERT\_ID()} va retourner une valeur différente. La commande \textbf{SELECT} lit cette valeur. La fonction C \textbf{mysql\_insert\_id()} peut aussi être utilisée pour lire la valeur. Vous pouvez générer des séquences sans appeler la fonction \textbf{LAST\_INSERT\_ID()}, mais l'utilité d'utiliser cette fonction cette fois ci est que la valeur ID est gérée par le serveur comme étant la dernière valeur générée automatiquement. (sécurité multi-utilisateur). Vous pouvez retrouver le nouvelle ID tout comme vous pouvez lire n'importe quelle valeur \textbf{AUTO\_INCREMENT} dans MySQL. Par exemple, la fonction \textbf{LAST\_INSERT\_ID()} (sans argument) devrait retourner la nouvelle ID.
\vspace{5mm} \\
 
 
\hspace{1mm}  La fonction C de l'API \textbf{mysql\_insert\_id()} peut être également utilisée pour trouver cette valeur. Notez que la fonction \textbf{mysql\_insert\_id()} est incrémentée uniquement après des requêtes \textbf{INSERT} et \textbf{UPDATE}, donc, vous ne pouvez pas utiliser la fonction C de l'API pour trouver la valeur de \textbf{LAST\_INSERT\_ID(expr)} après avoir exécuté d'autres types de requêtes, comme \textbf{SELECT} ou bien \textbf{SET}.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} SESSION\_USER()]{est un synonyme de USER().}
\item[\hspace{1mm} SYSTEM\_USER()]{est un synonyme de USER().}
\item[\hspace{1mm} USER()]{Retourne le nom d'utilisateur et le nom d'hôte courant MySQL. La valeur indique le nom d'utilisateur qui a été spécifié lors de l'identification avec le serveur MySQL, et l'hôte client avec lequel il est connecté}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT USER() ;} \\
\hspace{1mm} \textbf{-> 'davida@localhost'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} VERSION()]{Retourne une chaîne indiquant la version courante du serveur MySQL. Notez que si votre version se termine par -log, cela signifie que le système d'historique est actif.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT VERSION() ;} \\
\hspace{1mm} \textbf{-> '4.1.2-alpha-log'} \\
 
\vspace{1cm}{\huge Fonctions dans SELECT et WHERE - Fonctions diverses }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} FORMAT(X,D)]{Formate l'argument X en un format comme \textbf{'\#,\#\#\#,\#\#\#.\#\#'}, arrondi à D décimales. Si D vaut 0, le résultat n'aura ni séparateur décimal, ni partie décimale}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT FORMAT(12332.123456, 4) ;} \\
\hspace{1mm} \textbf{-> '12,332.1235'} \\
\hspace{1mm} \textbf{mysql> SELECT FORMAT(12332.1,4) ;} \\
\hspace{1mm} \textbf{-> '12,332.1000'} \\
\hspace{1mm} \textbf{mysql> SELECT FORMAT(12332.2,0) ;} \\
\hspace{1mm} \textbf{-> '12,332'} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} GET\_LOCK(str,timeout)]{Tente de poser un verrou nommé \textbf{str}, avec un délai d'expiration (\textbf{timeout}) exprimé en seconde. Retourne 1 si le verrou a été posé avec succès, 0 si il n'a pas pu être posé avant l'expiration du délai et NULL si une erreur est survenu (comme par exemple un manque de mémoire, ou la mort du thread lui-même, par mysqladmin kill). Un verrou sera levé lorsque vous exécuterez la commande \textbf{RELEASE\_LOCK()}, \textbf{GET\_LOCK()} ou si le thread se termine. Cette fonction peut être utilisée pour implémenter des verrous applicatifs ou pour simuler des verrous de lignes. Les requêtes concurrentes des autres clients de même nom seront bloquées ; les clients qui s'entendent sur un nom de verrou peuvent les utiliser pour effectuer des verrouillages coopératifs.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT GET\_LOCK("lock1",10) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT IS\_FREE\_LOCK("lock2") ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT GET\_LOCK("lock2",10) ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT RELEASE\_LOCK("lock2") ;} \\
\hspace{1mm} \textbf{-> 1} \\
\hspace{1mm} \textbf{mysql> SELECT RELEASE\_LOCK("lock1") ;} \\
\hspace{1mm} \textbf{-> NULL} \\
 
\hspace{1mm}  Notez que le deuxième appel à \textbf{RELEASE\_LOCK()} retourne \textbf{NULL} car le verrou "lock1" a été automatiquement libéré par le deuxième appel à \textbf{GET\_LOCK()}.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} INET\_ATON(expr)]{Retourne un entier qui représente l'expression numérique de l'adresse réseau. Les adresses peuvent être des entiers de 4 ou 8 octets.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT INET\_ATON("209.207.224.40") ;} \\
\hspace{1mm} \textbf{-> 3520061480} \\
 
\hspace{1mm}  Le nombre généré est toujours dans l'ordre des octets réseau ; par exemple, le nombre précédent est calculé comme ceci : \textbf{209*256\textasciicircum 3 + 207*256\textasciicircum 2 + 224*256 +40}. Depuis MySQL 4.1.2, INET\_ATON() comprend aussi les IP courtes
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT INET\_ATON('127.0.0.1'), INET\_ATON('127.1') ;} \\
\hspace{1mm} \textbf{-> 2130706433, 2130706433} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} INET\_NTOA(expr)]{Retourne l'adresse réseau (4 ou 8 octets), de l'expression numérique exp}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT INET\_NTOA(3520061480) ;} \\
\hspace{1mm} \textbf{-> "209.207.224.40"} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} IS\_FREE\_LOCK(str)]{Regarde si le verrou nommé str peut être librement utilisé (i.e., non verrouillé). Retourne 1 si le verrou est libre (personne ne l'utilise), 0 si le verrou est actuellement utilisé et NULL si une erreur survient (comme un argument incorrect).}
\item[\hspace{1mm} IS\_USED\_LOCK(str)]{Vérifie si le verrou appelé str est actuellement posé ou pas. Si c'est le cas, la fonction retourne l'identifiant de connexion qui a le verrou. Sinon, elle retourne NULL.}
\item[\hspace{1mm} MASTER\_POS\_WAIT(log\_name, log\_pos)]{Bloque le maître jusqu'à ce que l'esclave atteigne une position donnée dans le fichier d'historique principal, durant une réplication. Si l'historique principal n'est pas initialisé, retourne NULL. Si l'esclave n'est pas démarré, le maître restera bloqué jusqu'à ce que l'esclave soit démarré et ai atteint la position demandée. Si l'esclave a déjà dépassé cette position, la fonction se termine immédiatement. La valeur retournée est le nombre d'évènements qui a du être traité pour atteindre la position demandée, ou NULL en cas d'erreur. Cette fonction est très utile pour contrôler la synchronisation maître-esclave, mais elle a été initialement écrite pour faciliter les tests de réplications.}
\item[\hspace{1mm} RELEASE\_LOCK(str)]{Libère le verrou nommé str, obtenu par la fonction \textbf{GET\_LOCK()}. Retourne 1 si le verrou a bien été libéré, 0 si le verrou n'a pas été libéré par le thread (dans ce cas, le verrou reste posé) et NULL si le nom du verrou n'existe pas. Le verrou n'existe pas si il n'a pas été obtenu par la fonction \textbf{GET\_LOCK()} ou si il a déjà été libéré. La commande \textbf{DO} est utilisable avec \textbf{RELEASE\_LOCK()}.}
\item[\hspace{1mm} UUID()]{Retourne un Universal Unique Identifier (UUID) généré grâce à "DCE 1.1 : Remote Procedure Call" (Appendix A) CAE (Common Applications Environment) Specifications, publié par le The Open Group en octobre 1997 (Document numéro C706).}
\end{description}
 
\hspace{1mm}  Un \textbf{UUID} est conçu comme un numéro qui est globalement unique dans l'espace, et le temps. Deux appels à \textbf{UUID()} sont supposés générer deux valeurs différentes, même si ces appels sont faits sur deux ordinateurs séparés, qui ne sont pas connectés ensembles. Un \textbf{UUID} est un nombre de 128 bits, représenté par une chaîne de 5 nombres hexadécimaux, au format \textbf{aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee}: Les trois premiers nombres sont générés à partir d'un timestamp. Le quatrième nombre préserver l'unicité temporelle si le timestamp perd sa monotonie (par exemple, à cause du changement d'heure d'hiver/été). Le cinquième nombre est un nombre IEEE 802 qui fournit l'unicité. Un nombre aléatoire est utilisé la si ce dernier n'est pas disponible (par exemple, comme l'hôte n'a pas de carte Ethernet, nous ne savons pas comment trouver une adresse matériel sur le système d'exploitation). Dans ce cas, l'unicité spatiale ne peut être garantie. Néanmoins, une collision aura une très faible propriété.
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> SELECT UUID() ;} \\
\hspace{1mm} \textbf{-> '6ccd780c-baba-1026-9564-0040f4311e29'} \\
 
\vspace{1cm}{\huge Fonctions dans GROUP BY }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} AVG(expr)]{Retourne la moyenne de l'expression expr}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT student\_name, AVG(test\_score)} \\
\hspace{1mm} \textbf{-> FROM student} \\
\hspace{1mm} \textbf{-> GROUP BY student\_name ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} BIT\_AND(expr)]{Retourne la combinaison AND bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT).}
\item[\hspace{1mm} BIT\_OR(expr)]{Retourne la combinaison OR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT). Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.}
\item[\hspace{1mm} BIT\_XOR(expr)]{Retourne la combinaison XOR bit à bit de expr. Le calcul est fait en précision de 64 bits (BIGINT). Cette fonction retourne 0 s'il n'y a pas de ligne à traiter.}
\item[\hspace{1mm} COUNT(expr)]{Retourne le nombre de valeurs non-NULL dans les lignes lues par la commande SELECT}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT student.student\_name,COUNT(*)} \\
\hspace{1mm} \textbf{-> FROM student,course} \\
\hspace{1mm} \textbf{-> WHERE student.student\_id=course.student\_id} \\
\hspace{1mm} \textbf{-> GROUP BY student\_name ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} COUNT(*)]{est un peu différente dans son action, car elle retourne le nombre de lignes, même si elles contiennent NULL. COUNT(*) est optimisée pour retourner très rapidement un résultat si SELECT travaille sur une table, qu'aucune autre colonne n'est lue, et qu'il n'y a pas de clause WHERE. Par exemple:}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COUNT(*) FROM student ;} \\
 
\hspace{1mm}  Cette optimisation s'applique uniquement pour les tables MyISAM et ISAM, car un compte exact du nombre de lignes est stocké pour ces types de tables, et il peut être lu très rapidement. Pour les moteurs de tables transactionnels, (InnodB, BDB), le stockage de cette valeur est plus problématique, car plusieurs transactions peuvent survenir en même temps, et affecter ce compte.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} COUNT(DISTINCT expr,\texttt{[}expr...\texttt{]})]{Retourne le nombre de valeurs non-NULL distinctes:}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT COUNT(DISTINCT results) FROM student ;} \\
 
\hspace{1mm}  Avec MySQL, vous pouvez lire le nombre d'expression distinctes qui ne contiennent pas NULL, en plaçant ici une liste d'expression. Avec SQL-99, vous devriez faire une concaténation de toutes les expressions dans \textbf{COUNT(DISTINCT ...)}
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} GROUP\_CONCAT(expr)]{Syntaxe complète:}
\item[\hspace{1mm} GROUP\_CONCAT(\texttt{[}DISTINCT\texttt{]} expr \texttt{[},expr ...\texttt{]}]{}
\item[\hspace{1mm} \texttt{[}ORDER BY unsigned\_integer | col\_name | formula \texttt{[}ASC | DESC\texttt{]} \texttt{[},col ...\texttt{]}\texttt{]}]{}
\item[\hspace{1mm} \texttt{[}SEPARATOR str\_val\texttt{]})]{}
\item[\hspace{1mm} ]{Retourne la chaîne résultant de la concaténation de toutes les valeurs du groupe}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT student\_name,} \\
\hspace{1mm} \textbf{-> GROUP\_CONCAT(test\_score)} \\
\hspace{1mm} \textbf{-> FROM student} \\
\hspace{1mm} \textbf{-> GROUP BY student\_name ;} \\
\hspace{1mm} ou: \\
\hspace{1mm} \textbf{mysql> SELECT student\_name,} \\
\hspace{1mm} \textbf{-> GROUP\_CONCAT(DISTINCT test\_score} \\
\hspace{1mm} \textbf{-> ORDER BY test\_score DESC SEPARATOR " ")} \\
\hspace{1mm} \textbf{-> FROM student} \\
\hspace{1mm} \textbf{-> GROUP BY student\_name ;} \\
 
\hspace{1mm}  Avec MySQL, vous pouvez obtenir la concaténation d'une série d'expressions. Vous pouvez éliminer les doublons en utilisant \textbf{DISTINCT}. Si vous voulez trier les valeurs du résultat, il faut utiliser \textbf{ORDER BY}. Pour trier en ordre inverse, ajoutez le mot clé \textbf{DESC} (descendant) au nom de la colonne que vous triez dans la clause \textbf{ORDER BY}. Par défaut, l'ordre est ascendant. Cela peut être spécifié explicitement avec le mot clé \textbf{ASC}. \textbf{SEPARATOR} est une chaîne qui sera insérée entre chaque valeur du résultat. La valeur par défaut est une virgule ",". vous pouvez supprimer le séparateur en spécifiant la chaîne vide SEPARATOR "".
\vspace{5mm} \\
 
 
\hspace{1mm}  Vous pouvez donner une taille maximale à la variable \textbf{group\_concat\_max\_len} de votre configuration. La syntaxe pour faire cela durant l'exécution est
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{SET [SESSION | GLOBAL] group\_concat\_max\_len = unsigned\_integer ;} \\
 
\hspace{1mm}  Si une taille maximale a été atteinte, le résultat sera tronqué à cette taille maximale. Note : il y a encore de petites limitations pour \textbf{GROUP\_CONCAT()} lorsqu'il faut utiliser des valeurs \textbf{DISTINCT} avec \textbf{ORDER BY} et et en utilisant les valeurs \textbf{BLOB}.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} MIN(expr), MAX(expr)]{Retourne le minimum ou le maximum de \textbf{expr}. MIN() et MAX() peuvent prendre des chaînes comme argument: dans ce cas, elles retournent la valeur minimale ou maximale de la valeur de la chaîne.}
\end{description}
 
\hspace{1mm} \textbf{mysql> SELECT student\_name, MIN(test\_score), MAX(test\_score)} \\
\hspace{1mm} \textbf{-> FROM student} \\
\hspace{1mm} \textbf{-> GROUP BY student\_name ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} STD(expr), STDDEV(expr)]{Retourne la déviation standard de \textbf{expr} la racine carrée de la \textbf{VARIANCE()}. Ceci est une extension au standard SQL 99. La forme \textbf{STDDEV()} de cette fonction est fournie pour assurer la compatibilité Oracle.}
\item[\hspace{1mm} SUM(expr)]{Retourne la somme de \textbf{expr}. Notez que si le résultat ne contient pas de ligne, cette fonction retournera NULL.}
\item[\hspace{1mm} VARIANCE(expr)]{Retourne la variance standard de l'expression \textbf{expr} (en considérant que les lignes forment une population totale, et non pas un échantillon. Le nombre de ligne est le dénominateur.}
\end{description}
 
\vspace{1cm}{\huge Procédures stockées et fonctions }
 
\
 
\hspace{1mm}  Une procédure stockées est un jeu de commandes SQL qui réside sur le serveur. Une fois qu'elle sont enregistrées, les clients n'ont pas besoin de soumettre chaque commande individuellement, mais peuvent les lancer d'un seul coup.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les procédures stockées fournissent un gain de performances, car moins d'informations sont échangées entre le serveur et le client. En échange, cela augmente la charge du serveur, car ce dernier doit réaliser plus de travail. Souvent, il y a de nombreux clients, mais peut de serveurs.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} -]{Les procédures stockées requièrent la table \textbf{proc} dans la base mysql.}
\item[\hspace{1mm} -]{Le droit de \textbf{CREATE ROUTINE} est nécessaire pour créer une procédure stockée.}
\item[\hspace{1mm} -]{Le droit de \textbf{ALTER ROUTINE} est nécessaire pour pouvoir modifier ou effacer une procédure stockée. Le droit est fourni automatiquement au créateur d'une routine.}
\item[\hspace{1mm} -]{Le droit de \textbf{EXECUTE} est requis pour exécuter une procédure stockée. Cependant, ce droit est fourni automatiquement au créateur d'une routine. De plus, la caractéristique par défaut \textbf{SQL SECURITY} est définie (\textbf{DEFINER}), ce qui fait que les utilisateurs qui ont accès à une base de données associée à une routine ont le droit d'exécuter la routine}
\end{description}
 
\vspace{1cm}{\huge Déclencheurs }
 
\
 
\hspace{1mm}  Un déclencheur est un objet de base de données nommé, qui est associé à une table et qui s'active lorsqu'un événement particulier survient dans une table. les commandes suivantes configurent une table, ainsi qu'un déclencheur pour les commandes \textbf{INSERT} sur cette table. Le déclencheur va effectuer la somme des valeurs insérées dans une des colonnes
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> CREATE TABLE account (acct\_num INT, amount DECIMAL(10,2)) ;} \\
\hspace{1mm} \textbf{mysql> CREATE TRIGGER ins\_sum BEFORE INSERT ON account} \\
\hspace{1mm} \textbf{-> FOR EACH ROW SET @sum = @sum + NEW.amount ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} CREATE TRIGGER]{}
\item[\hspace{1mm} CREATE TRIGGER trigger\_name trigger\_time trigger\_event ON tbl\_name FOR EACH ROW trigger\_stmt]{}
\end{description}
 
\hspace{1mm}  Le déclencheur est associé à la table appelée \textbf{tbl\_name}. \textbf{tbl\_name} doit faire référence à une table permanente. Vous ne pouvez pas associer un déclencheur avec une table \textbf{TEMPORARY} ou une vue. \textbf{trigger\_time} est le moment d'action du déclencheur. Il peut être \textbf{BEFORE} (avant) ou \textbf{AFTER} (après). \textbf{trigger\_event} indique le type de commande qui active le déclencheur. Il peut valoir \textbf{INSERT}, \textbf{UPDATE} ou \textbf{DELETE}. Il ne peut pas y avoir deux déclencheurs pour une même table avec les mêmes configurations de moment et de commande.
\vspace{5mm} \\
 
 
\hspace{1mm}  \textbf{trigger\_stmt} est la commande à exécuter lorsque le déclencheur s'active. Si vous voulez utiliser plusieurs commandes, utilisez les agrégateurs \textbf{BEGIN ... END}. Cela vous permet aussi d'utiliser les mêmes codes que ceux utilisés dans des procédures stockées. Dans la commande d'activation d'un déclencheur, vous pouvez faire référence aux colonnes dans la table associée au déclencheur en utilisant les mots \textbf{OLD} et \textbf{NEW}. \textbf{OLD.col\_name} fait référence à une colonne d'une ligne existante avant sa modification ou son effacement. \textbf{NEW.col\_name} fait référence à une colonne d'une ligne après insertion ou modification.
\vspace{5mm} \\
 
 
\hspace{1mm}  L'utilisation de \textbf{SET NEW.col\_name = value} requiert le droit de \textbf{UPDATE} sur la colonne. L'utilisation de \textbf{SET value = NEW.col\_name} requiert le droit de \textbf{SELECT} sur la colonne. La commande \textbf{CREATE TRIGGER} requiert le droit de \textbf{SUPER}.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} DROP TRIGGER]{}
\item[\hspace{1mm} DROP TRIGGER tbl\_name.trigger\_name]{Supprime un déclencheur. Le nom du déclencheur doit inclure le nom de la table, car chaque déclencheur est associé à une table particulière. La commande \textbf{DROP TRIGGER} requiert le droit de \textbf{SUPER}.}
\end{description}
 
\vspace{1cm}{\huge Vues }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} ALTER VIEW]{}
\item[\hspace{1mm} ALTER VIEW view\_name \texttt{[}(column\_list)\texttt{]} AS select\_statement]{Cette commande modifie la définition d'une vue. \textbf{select\_statement} est le même que pour \textbf{CREATE VIEW}}
\item[\hspace{1mm} CREATE VIEW]{CREATE [OR REPLACE] [ALGORITHM = MERGE | TEMPTABLE] VIEW view\_name [(column\_list)] AS select\_statement [WITH [CASCADED | LOCAL] CHECK OPTION]}
\item[\hspace{1mm} ]{}
\item[\hspace{1mm} Cette commande crée une nouvelle vue, ou remplace une vue existante si la clause \textbf{OR REPLACE} est fournie. La clause \textbf{select\_statement} est une commande \textbf{SELECT} qui fournit la définition de la vue. La liste optionnelle de colonnes peut être fournie pour définir explicitement les noms des colonnes. Une vue peut être créée par différents types de commandes \textbf{SELECT}.]{}
\item[\hspace{1mm} Par exemple, \textbf{SELECT} peut faire référence à une table seule, une jointure ou une \textbf{UNION}. La commande \textbf{SELECT} peut ne pas faire de référence à une table. Les exemples suivants définissent une vue qui sélectionne 2 colonnes dans une table, et leur applique une transformation]{}
\end{description}
 
\hspace{1mm} \textbf{mysql> CREATE TABLE t (qty INT, price INT) ;} \\
\hspace{1mm} \textbf{mysql> INSERT INTO t VALUES(3, 50) ;} \\
\hspace{1mm} \textbf{mysql> CREATE VIEW v AS SELECT qty, price, qty*price AS value FROM t ;} \\
\hspace{1mm} \textbf{mysql> SELECT * FROM v ;} \\
 
\hspace{1mm}  Par défaut, la vue est placée dans la base de données par défaut. Pour créer une vue explicitement dans une base de données, spécifiez le nom de la base de données lors de la création: \textbf{db\_name.view\_name}
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{mysql> CREATE VIEW test.v AS SELECT * FROM t ;} \\
 
\begin{description} \normalsize
\item[\hspace{1mm} DROP VIEW]{}
\item[\hspace{1mm} DROP VIEW \texttt{[}IF EXISTS\texttt{]} view\_name \texttt{[}, view\_name\texttt{]} ... \texttt{[}RESTRICT | CASCADE\texttt{]}]{DROP VIEW supprime une ou plusieurs vues. Vous devez avoir les droits de \textbf{DROP} pour chaque vue.}
\item[\hspace{1mm} SHOW CREATE VIEW]{}
\item[\hspace{1mm} SHOW CREATE VIEW view\_name]{Cette commande montre la commande \textbf{CREATE VIEW} qui créera la vue spécifiée.}
\end{description}
 
\vspace{1cm}{\huge INFORMATION\_SCHEMA }
 
\
 
\hspace{1mm}  Les \textbf{métadonnées} sont des informations sur les données, telles que le nom des bases de données, des tables, le type de données des colonnes ou les droits d'accès. On appelle aussi ces données le \textbf{dictionnaire de données} ou le \textbf{catalogue système}.
\vspace{5mm} \\
 
\end{flushleft}
\end{document}
